diff --git a/wiki/TSL.md b/docs/TSL.md
similarity index 100%
rename from wiki/TSL.md
rename to docs/TSL.md
diff --git a/docs/llms-full.txt b/docs/llms-full.txt
new file mode 100644
index 00000000000000..bd6cb381ffd596
--- /dev/null
+++ b/docs/llms-full.txt
@@ -0,0 +1,2617 @@
+# Three.js
+
+> Three.js is a cross-browser JavaScript library for creating 3D graphics using WebGL and WebGPU.
+
+## Instructions for Large Language Models
+
+When generating Three.js code, follow these guidelines:
+
+### 1. Use Import Maps (Not Old CDN Patterns)
+
+WRONG - outdated pattern:
+```html
+
+```
+
+CORRECT - modern pattern (always use latest version):
+```html
+
+
+```
+
+### 2. Choosing Between WebGLRenderer and WebGPURenderer
+
+Three.js maintains both renderers:
+
+**Use WebGLRenderer** (default, mature):
+- Maximum browser compatibility
+- Well-established, many years of development
+- Most examples and tutorials use this
+
+```js
+import * as THREE from 'three';
+const renderer = new THREE.WebGLRenderer();
+```
+
+**Use WebGPURenderer** when you need:
+- Custom shaders/materials using TSL (Three.js Shading Language)
+- Compute shaders
+- Advanced node-based materials
+
+```js
+import * as THREE from 'three/webgpu';
+const renderer = new THREE.WebGPURenderer();
+await renderer.init();
+```
+
+### 3. TSL (Three.js Shading Language)
+
+When using WebGPURenderer, use TSL instead of raw GLSL for custom materials:
+
+```js
+import { texture, uv, color } from 'three/tsl';
+
+const material = new THREE.MeshStandardNodeMaterial();
+material.colorNode = texture( myTexture ).mul( color( 0xff0000 ) );
+```
+
+TSL benefits:
+- Works with both WebGL and WebGPU backends
+- No string manipulation or onBeforeCompile hacks
+- Type-safe, composable shader nodes
+- Automatic optimization
+
+### 4. NodeMaterial Classes (for WebGPU/TSL)
+
+When using TSL, use node-based materials:
+- MeshBasicNodeMaterial
+- MeshStandardNodeMaterial
+- MeshPhysicalNodeMaterial
+- LineBasicNodeMaterial
+- SpriteNodeMaterial
+
+---
+
+## Complete Code Examples
+
+### Basic Scene with WebGLRenderer
+
+```html
+
+
+
+ Three.js Basic Scene
+
+
+
+
+
+
+
+```
+
+### Basic Scene with WebGPURenderer and TSL
+
+```html
+
+
+
+ Three.js WebGPU Scene
+
+
+
+
+
+
+
+```
+
+### Loading a GLTF Model
+
+```js
+import * as THREE from 'three';
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+
+const loader = new GLTFLoader();
+
+loader.load(
+ 'model.glb',
+ ( gltf ) => {
+ scene.add( gltf.scene );
+ },
+ ( progress ) => {
+ console.log( ( progress.loaded / progress.total * 100 ) + '% loaded' );
+ },
+ ( error ) => {
+ console.error( 'Error loading model:', error );
+ }
+);
+```
+
+---
+
+# TSL (Three.js Shading Language) - Complete Reference
+
+## TSL Specification
+
+An Approach to Productive and Maintainable Shader Creation.
+
+- [Introduction](#introduction)
+ - [Why TSL?](#why-tsl)
+ - [Example](#example)
+ - [Architecture](#architecture)
+- [Learning TSL](#learning-tsl)
+- [Constants and explicit conversions](#constants-and-explicit-conversions)
+- [Conversions](#conversions)
+- [Uniform](#uniform)
+ - [onUpdate](#uniformonupdate)
+- [Swizzle](#swizzle)
+- [Operators](#operators)
+- [Function](#function)
+- [Variables](#variables)
+- [Array](#array)
+ - [Uniform](#array-uniform)
+- [Varying](#varying)
+- [Conditional](#conditional)
+ - [If-else](#if-else)
+ - [Switch-case](#switch-case)
+ - [Ternary](#ternary)
+- [Loop](#loop)
+- [Math](#math)
+- [Method chaining](#method-chaining)
+- [Texture](#texture)
+- [Attributes](#attributes)
+- [Position](#position)
+- [Normal](#normal)
+- [Tangent](#tangent)
+- [Bitangent](#bitangent)
+- [Camera](#camera)
+- [Model](#model)
+- [Screen](#screen)
+- [Viewport](#viewport)
+- [Blend Modes](#blend-modes)
+- [Reflect](#reflect)
+- [UV Utils](#uv-utils)
+- [Interpolation](#interpolation)
+- [Random](#random)
+- [Rotate](#rotate)
+- [Oscillator](#oscillator)
+- [Timer](#timer)
+- [Packing](#packing)
+- [Post-Processing](#post-processing)
+- [Render Pass](#render-pass)
+- [Compute](#compute)
+- [Storage](#storage)
+- [Struct](#struct)
+- [Flow Control](#flow-control)
+- [Fog](#fog)
+- [Color Adjustments](#color-adjustments)
+- [Utilities](#utilities)
+- [NodeMaterial](#nodematerial)
+ - [LineDashedNodeMaterial](#linedashednodematerial)
+ - [MeshPhongNodeMaterial](#meshphongnodematerial)
+ - [MeshStandardNodeMaterial](#meshstandardnodematerial)
+ - [MeshPhysicalNodeMaterial](#meshphysicalnodematerial)
+ - [SpriteNodeMaterial](#spritenodematerial)
+- [Transitioning common GLSL properties to TSL](#transitioning-common-glsl-properties-to-tsl)
+
+## Introduction
+
+### Why TSL?
+
+Creating shaders has always been an advanced step for most developers; many game developers have never created GLSL code from scratch. The shader graph solution adopted today by the industry has allowed developers more focused on dynamics to create the necessary graphic effects to meet the demands of their projects.
+
+The aim of the project is to create an easy-to-use environment for shader creation. Even if for this we need to create complexity behind it, this happened initially with `Renderer` and now with the `TSL`.
+
+Other benefits that TSL brings besides simplifying shading creation are keeping the `renderer agnostic`, while all the complexity of a material can be imported into different modules and use `tree shaking` without breaking during the process.
+
+### Example
+
+A `detail map` makes things look more real in games. It adds tiny details like cracks or bumps to surfaces. In this example we will scale uv to improve details when seen up close and multiply with a base texture.
+
+#### Old
+
+This is how we would achieve that using `.onBeforeCompile()`:
+
+```js
+const material = new THREE.MeshStandardMaterial();
+material.map = colorMap;
+material.onBeforeCompile = ( shader ) => {
+
+ shader.uniforms.detailMap = { value: detailMap };
+
+ let token = '#define STANDARD';
+
+ let insert = /* glsl */`
+ uniform sampler2D detailMap;
+ `;
+
+ shader.fragmentShader = shader.fragmentShader.replace( token, token + insert );
+
+ token = '#include ';
+
+ insert = /* glsl */`
+ diffuseColor *= texture2D( detailMap, vMapUv * 10.0 );
+ `;
+
+ shader.fragmentShader = shader.fragmentShader.replace( token, token + insert );
+
+};
+```
+
+Any simple change from this makes the code increasingly complicated using `.onBeforeCompile`, the result we have today in the community are countless types of parametric materials that do not communicate with each other, and that need to be updated periodically to be operating, limiting the creativity to create unique materials reusing modules in a simple way.
+
+#### New
+
+With `TSL` the code would look like this:
+
+```js
+import { texture, uv } from 'three/tsl';
+
+const detail = texture( detailMap, uv().mul( 10 ) );
+
+const material = new THREE.MeshStandardNodeMaterial();
+material.colorNode = texture( colorMap ).mul( detail );
+```
+
+`TSL` is also capable of encoding code into different outputs such as `WGSL`/`GLSL` - `WebGPU`/`WebGL`, in addition to optimizing the shader graph automatically and through codes that can be inserted within each `Node`. This allows the developer to focus on productivity and leave the graphical management part to the `Node System`.
+
+Another important feature of a graph shader is that we will no longer need to care about the sequence in which components are created, because the `Node System` will only declare and include it once.
+
+Let's say that you import `positionWorld` into your code, even if another component uses it, the calculations performed to obtain `position world` will only be performed once, as is the case with any other node such as: `normalWorld`, `modelPosition`, etc.
+
+### Architecture
+
+All `TSL` components are extended from `Node` class. The `Node` allows it to communicate with any other, value conversions can be automatic or manual, a `Node` can receive the output value expected by the parent `Node` and modify its own output snippet. It's possible to modulate them using `tree shaking` in the shader construction process, the `Node` will have important information such as `geometry`, `material`, `renderer` as well as the `backend`, which can influence the type and value of output.
+
+The main class responsible for creating the code is `NodeBuilder`. This class can be extended to any output programming language, so you can use TSL for a third language if you wish. Currently `NodeBuilder` has two extended classes, the `WGSLNodeBuilder` aimed at WebGPU and `GLSLNodeBuilder` aimed at WebGL2.
+
+The build process is based on three pillars: `setup`, `analyze` and `generate`.
+
+| | |
+| -- | -- |
+| `setup` | Use `TSL` to create a completely customized code for the `Node` output. The `Node` can use many others within itself, have countless inputs, but there will always be a single output. |
+| `analyze` | This proccess will check the `nodes` that were created in order to create useful information for `generate` the snippet, such as the need to create or not a cache/variable for optimizing a node. |
+| `generate` | An output of `string` will be returned from each `node`. Any node will also be able to create code in the flow of shader, supporting multiple lines. |
+
+`Node` also have a native update process invoked by the `update()` function, these events be called by `frame`, `render call` and `object draw`.
+
+It is also possible to serialize or deserialize a `Node` using `serialize()` and `deserialize()` functions.
+
+## Learning TSL
+
+TSL is a Node-based shader abstraction, written in JavaScript. TSL's functions are inspired by GLSL, but follow a very different concept. WGSL and GLSL are focused on creating GPU programs, in TSL this is one of the features.
+
+### Seamless Integration with JavaScript/TypeScript
+
+- Unified Code
+ - Write shader logic directly in JS/TS, eliminating the need to manipulate strings.
+ - Create and manipulate render objects just like any other JavaScript logic inside a TSL function.
+ - Advanced events to control a Node before and after the object is rendered.
+- JS Ecosystem
+ - Use native **import/export**, **NPM**, and integrate **JS/TS** components directly into your shader logic.
+- Typing
+ - Benefit from better type checking (especially with **TypeScript** and **[@three-types](https://github.com/three-types/three-ts-types)**), increasing code robustness.
+
+### Shader-Graph Inspired Structure
+
+- Focus on Intent
+ - Build materials by connecting nodes through: [positionWorld](#position), [normalWorld](#normal), [screenUV](#screen), [attribute()](#attributes), etc.
+More declarative("what") vs. imperative("how").
+- Composition & High-Level Concepts
+ - Work with high-level concepts for Node Material like [colorNode](#basic), [roughnessNode](#standard), [metalnessNode](#standard), [positionNode](#basic), etc. This preserves the integrity of the lighting model while allowing customizations, helping to avoid mistakes from incorrect setups.
+- Keeping an eye on software exchange
+ - Modern 3D authoring software uses Shader-Graph based material composition to exchange between other software. TSL already has its own MaterialX integration.
+- Easier Migration
+ - Many functions are directly inspired by GLSL to smooth the learning curve for those with prior experience.
+
+### Rendering Manipulation
+
+- Control rendering steps and create new render-passes per individual TSL functions.
+ - Implement complex effects is easily with nodes using a single function call either in post-processing and in materials allowing the node itself to manage the rendering process as it needs.
+ - `gaussianBlur()`: Double render-pass gaussian blur node. It can be used in the material or in post-processing through a single function.
+ - Easy access to renderer buffers using TSL functions like:
+ - `viewportSharedTexture()`: Accesses the beauty what has already been rendered, preserving the render-order.
+ - `viewportLinearDepth()`: Accesses the depth what has already been rendered, preserving the render-order.
+ - Integrated Compute Shaders
+ - Perform calculations on buffers using compute stage directly during an object's rendering.
+ - TSL allows dynamic manipulation of renderer functions, which makes it more customizable than intermediate languages that would have to use flags in fixed pipelines for this.
+ - You just need to use the events of a Node for the renderer manipulations, without needing to modify the core.
+
+### Automatic Optimization and Workarounds
+
+- Your TSL code automatically benefits from optimizations and workarounds implemented in the Three.js compiler with each new version.
+ - Simplifications
+ - Automatic type conversions.
+ - Execute a block of code in vertex-stage and get it in fragment-stage just using `vertexStage( node )`.
+ - Automatically choose interpolation method for varyings depending on type.
+ - Don't worry about collisions of global variables internally when using Nodes.
+ - Polyfills
+ - e.g: `textureSample()` function in the vertex shader (not natively supported in WGSL) is correctly transpiled to work.
+ - e.g: Automatic correction for the `pow()` function, which didn't accept negative bases on Windows/DirectX using WGSL.
+ - Optimizations
+ - Repeated expressions: TSL can automatically create temporary variables to avoid redundant calculations.
+ - Automatic reuse of uniforms and attributes.
+ - Creating varying only if necessary. Otherwise they are replaced by simple variables.
+
+### Target audience
+ - Beginners users
+ - You only need one line to create your first custom shader.
+ - Advanced users
+ - Makes creating shaders simple but not limited. Example: https://www.youtube.com/watch?v=C2gDL9Qk_vo
+ - If you don't like fixed pipelines and low level, you'll love this.
+
+### Share everything
+
+#### TSL is based on Nodes, so don’t worry about sharing your **functions** and **uniforms** across materials and post-processing.
+
+```js
+// Shared the same uniform with various materials
+
+const sharedColor = uniform( new THREE.Color() );
+
+materialA.colorNode = sharedColor.div( 2 );
+materialB.colorNode = sharedColor.mul( .5 );
+materialC.colorNode = sharedColor.add( .5 );
+```
+
+#### Deferred Function: High level of customization, goodby **#defines**
+
+Access **material**, **geometry**, **object**, **camera**, **scene**, **renderer** and more directly from a TSL function. Function calls are only performed at the time of building the shader allowing you to customize the function according to the object's setup.
+
+```js
+// Returns an uniform of the material's custom color if it exists
+
+const customColor = Fn( ( { material, geometry, object } ) => {
+
+ if ( material.userData.customColor !== undefined ) {
+
+ return uniform( material.userData.customColor );
+
+ }
+
+ return vec3( 0 );
+
+} );
+
+//
+
+material.colorNode = customColor();
+
+```
+
+#### Load a texture-based matrix inside a TSL function
+
+This can be used for any other JS and Three.js ecosystem needs. You can manipulate your assets according to the needs of a function. This can work for creating buffers, attributes, uniforms and any other JavaScript operation.
+
+```js
+let bayer16Texture = null;
+
+export const bayer16 = Fn( ( [ uv ] ) => {
+
+ if ( bayer16Texture === null ) {
+
+ const bayer16Base64 = 'data:image/png;base64,...==';
+
+ bayer16Texture = new TextureLoader().load( bayer16Base64 );
+
+ }
+
+ return textureLoad( bayer16Texture, ivec2( uv ).mod( int( 16 ) ) );
+
+} );
+
+//
+
+material.colorNode = bayer16( screenCoordinate );
+
+```
+
+#### The node architecture allows the creation of instances of custom attributes and buffers through simple functions.
+
+```js
+// Range values node example
+
+const randomColor = range( new THREE.Color( 0x000000 ), new THREE.Color( 0xFFFFFF ) );
+
+material.colorNode = randomColor;
+
+//...
+
+const mesh = new THREE.InstancedMesh( geometry, material, count );
+```
+
+#### TSL loves JavaScript
+
+TSL syntax follows JavaScript style because they are the same thing, so if you come from GLSL you can explore new possibilities.
+
+```js
+// A simple example of Function closure
+
+const mainTask = Fn( () => {
+
+ const task2 = Fn( ( [ a, b ] ) => {
+
+ return a.add( b ).mul( 0.5 );
+
+ } );
+
+
+ return task2( color( 0x00ff00 ), color( 0x0000ff ) );
+
+} );
+
+//
+
+material.colorNode = mainTask();
+```
+
+#### Simplification
+
+Double render-pass `gaussianBlur()` node. It can be used in the material or in post-processing through a single function.
+
+```js
+// Applies a double render-pass gaussianBlur and then a grayscale filter before the object with the material is rendered.
+
+const myTexture = texture( map );
+
+material.colorNode = grayscale( gaussianBlur( myTexture, 4 ) );
+```
+
+Accesses what has already been rendered, preserving the render-order for easy refraction effects, avoiding multiple render-pass and manual sorts.
+
+```js
+// Leaving the back in grayscale.
+
+material.colorNode = grayscale( viewportSharedTexture( screenUV ) );
+material.transparent = true;
+```
+
+#### Extend the TSL
+
+You no longer need to create a Material for each desired effect, instead create Nodes. A Node can have access to the Material and can be used in many ways. Extend the TSL from Nodes and let the user use it in creative ways.
+
+A great example of this is [TSL-Textures](https://boytchev.github.io/tsl-textures/).
+
+```js
+import * as THREE from 'three';
+import { simplexNoise } from 'tsl-textures';
+
+material.colorNode = simplexNoise ( {
+ scale: 2,
+ balance: 0,
+ contrast: 0,
+ color: new THREE.Color(16777215),
+ background: new THREE.Color(0),
+ seed: 0
+} );
+
+```
+
+## Constants and explicit conversions
+
+Input functions can be used to create contants and do explicit conversions.
+> Conversions are also performed automatically if the output and input are of different types.
+
+| Name | Returns a constant or convertion of type: |
+| -- | -- |
+| `float( node\|number )` | `float` |
+| `int( node\|number )` | `int` |
+| `uint( node\|number )` | `uint` |
+| `bool( node\|value )` | `boolean` |
+| `color( node\|hex\|r,g,b )` | `color` |
+| `vec2( node\|Vector2\|x,y )` | `vec2` |
+| `vec3( node\|Vector3\|x,y,z )` | `vec3` |
+| `vec4( node\|Vector4\|x,y,z,w )` | `vec4` |
+| `mat2( node\|Matrix2\|a,b,c,d )` | `mat2` |
+| `mat3( node\|Matrix3\|a,b,c,d,e,f,g,h,i )` | `mat3` |
+| `mat4( node\|Matrix4\|a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p )` | `mat4` |
+| `ivec2( node\|x,y )` | `ivec2` |
+| `ivec3( node\|x,y,z )` | `ivec3` |
+| `ivec4( node\|x,y,z,w )` | `ivec4` |
+| `uvec2( node\|x,y )` | `uvec2` |
+| `uvec3( node\|x,y,z )` | `uvec3` |
+| `uvec4( node\|x,y,z,w )` | `uvec4` |
+| `bvec2( node\|x,y )` | `bvec2` |
+| `bvec3( node\|x,y,z )` | `bvec3` |
+| `bvec4( node\|x,y,z,w )` | `bvec4` |
+
+Example:
+
+```js
+import { color, vec2, positionWorld } from 'three/tsl';
+
+// constant
+material.colorNode = color( 0x0066ff );
+
+// conversion
+material.colorNode = vec2( positionWorld ); // result positionWorld.xy
+```
+
+## Conversions
+
+It is also possible to perform conversions using the `method chaining`:
+
+| Name | Returns a constant or conversion of type: |
+| -- | -- |
+| `.toFloat()` | `float` |
+| `.toInt()` | `int` |
+| `.toUint()` | `uint` |
+| `.toBool()` | `boolean` |
+| `.toColor()` | `color` |
+| `.toVec2()` | `vec2` |
+| `.toVec3()` | `vec3` |
+| `.toVec4()` | `vec4` |
+| `.toMat2()` | `mat2` |
+| `.toMat3()` | `mat3` |
+| `.toMat4()` | `mat4` |
+| | |
+| `.toIVec2()` | `ivec2` |
+| `.toIVec3()` | `ivec3` |
+| `.toIVec4()` | `ivec4` |
+| `.toUVec2()` | `uvec2` |
+| `.toUVec3()` | `uvec3` |
+| `.toUVec4()` | `uvec4` |
+| `.toBVec2()` | `bvec2` |
+| `.toBVec3()` | `bvec3` |
+| `.toBVec4()` | `bvec4` |
+
+Example:
+
+```js
+import { positionWorld } from 'three/tsl';
+
+// conversion
+material.colorNode = positionWorld.toVec2(); // result positionWorld.xy
+```
+
+## Uniform
+
+Uniforms are useful to update values of variables like colors, lighting, or transformations without having to recreate the shader program. They are the true variables from a GPU's point of view.
+
+| Name | Description |
+| -- | -- |
+| `uniform( boolean \| number \| Color \| Vector2 \| Vector3 \| Vector4 \| Matrix3 \| Matrix4, type = null )` | Dynamic values. |
+
+Example:
+
+```js
+const myColor = uniform( new THREE.Color( 0x0066FF ) );
+
+material.colorNode = myColor;
+```
+
+### `uniform.on*Update()`
+
+It is also possible to create update events on `uniforms`, which can be defined by the user:
+
+| Name | Description |
+| -- | -- |
+| `.onObjectUpdate( function )` | It will be updated every time an object like `Mesh` is rendered with this `node` in `Material`. |
+| `.onRenderUpdate( function )` | It will be updated once per render, common and shared materials, fog, tone mapping, etc. |
+| `.onFrameUpdate( function )` | It will be updated only once per frame, recommended for values that will be updated only once per frame, regardless of when `render-pass` the frame has, cases like `time` for example. |
+
+Example:
+
+```js
+const posY = uniform( 0 ); // it's possible use uniform( 'float' )
+
+// or using event to be done automatically
+// { object } will be the current rendering object
+posY.onObjectUpdate( ( { object } ) => object.position.y );
+
+// you can also update manually using the .value property
+posY.value = object.position.y;
+
+material.colorNode = posY;
+```
+
+## Swizzle
+
+Swizzling is the technique that allows you to access, reorder, or duplicate the components of a vector using a specific notation within TSL. This is done by combining the identifiers:
+
+```js
+const original = vec3( 1.0, 2.0, 3.0 ); // (x, y, z)
+const swizzled = original.zyx; // swizzled = (3.0, 2.0, 1.0)
+```
+
+It's possible use `xyzw`, `rgba` or `stpq`.
+
+## Operators
+
+| Name | Description |
+| -- | -- |
+| `.add( node \| value, ... )` | Return the addition of two or more value. |
+| `.sub( node \| value )` | Return the subraction of two or more value. |
+| `.mul( node \| value )` | Return the multiplication of two or more value. |
+| `.div( node \| value )` | Return the division of two or more value. |
+| `.mod( node \| value )` | Computes the remainder of dividing the first node by the second. |
+| `.equal( node \| value )` | Checks if two nodes are equal. |
+| `.notEqual( node \| value )` | Checks if two nodes are not equal. |
+| `.lessThan( node \| value )` | Checks if the first node is less than the second. |
+| `.greaterThan( node \| value )` | Checks if the first node is greater than the second. |
+| `.lessThanEqual( node \| value )` | Checks if the first node is less than or equal to the second. |
+| `.greaterThanEqual( node \| value )` | Checks if the first node is greater than or equal to the second. |
+| `.and( node \| value )` | Performs logical AND on two nodes. |
+| `.or( node \| value )` | Performs logical OR on two nodes. |
+| `.not( node \| value )` | Performs logical NOT on a node. |
+| `.xor( node \| value )` | Performs logical XOR on two nodes. |
+| `.bitAnd( node \| value )` | Performs bitwise AND on two nodes. |
+| `.bitNot( node \| value )` | Performs bitwise NOT on a node. |
+| `.bitOr( node \| value )` | Performs bitwise OR on two nodes. |
+| `.bitXor( node \| value )` | Performs bitwise XOR on two nodes. |
+| `.shiftLeft( node \| value )` | Shifts a node to the left. |
+| `.shiftRight( node \| value )` | Shifts a node to the right. |
+| | |
+| `.assign( node \| value )` | Assign one or more value to a and return the same. |
+| `.addAssign( node \| value )` | Adds a value and assigns the result. |
+| `.subAssign( node \| value )` | Subtracts a value and assigns the result. |
+| `.mulAssign( node \| value )` | Multiplies a value and assigns the result. |
+| `.divAssign( node \| value )` | Divides a value and assigns the result. |
+
+```js
+const a = float( 1 );
+const b = float( 2 );
+
+const result = a.add( b ); // output: 3
+```
+
+## Function
+
+### `Fn( function, layout = null )`
+
+It is possible to use classic JS functions or a `Fn()` interface. The main difference is that `Fn()` creates a controllable environment, allowing the use of `stack` where you can use `assign` and `conditional`, while the classic function only allows inline approaches.
+
+Example:
+
+```js
+// tsl function
+const oscSine = Fn( ( [ t = time ] ) => {
+
+ return t.add( 0.75 ).mul( Math.PI * 2 ).sin().mul( 0.5 ).add( 0.5 );
+
+} );
+
+// inline function
+export const oscSine = ( t = time ) => t.add( 0.75 ).mul( Math.PI * 2 ).sin().mul( 0.5 ).add( 0.5 );
+```
+> Both above can be called with `oscSin( value )`.
+
+TSL allows the entry of parameters as object, this is useful in functions that have many optional arguments.
+
+Example:
+
+```js
+const oscSine = Fn( ( { timer = time } ) => {
+
+ return timer.add( 0.75 ).mul( Math.PI * 2 ).sin().mul( 0.5 ).add( 0.5 );
+
+} );
+
+const value = oscSine( { timer: value } );
+```
+
+Parameters as object also allows traditional calls as an array, enabling different types of usage.
+
+```js
+const col = Fn( ( { r, g, b } ) => {
+
+ return vec3( r, g, b );
+
+} );
+
+
+// Any of the options below will return a green color.
+
+material.colorNode = col( 0, 1, 0 ); // option 1
+material.colorNode = col( { r: 0, g: 1, b: 0 } ); // option 2
+```
+
+If you want to use an export function compatible with `tree shaking`, remember to use `/*@__PURE__*/`
+
+```js
+export const oscSawtooth = /*@__PURE__*/ Fn( ( [ timer = time ] ) => timer.fract() );
+```
+
+The second parameter of the function, if there are any parameters, will always be the first if there are none, and is dedicated to `NodeBuilder`. In `NodeBuilder` you can find out details about the current construction process and also obtain objects related to the shader construction, such as `material`, `geometry`, `object`, `camera`, etc.
+
+[See an example](#deferred-function-high-level-of-customization-goodby-defines)
+
+## Variables
+
+Functions used to declare variables.
+
+| Name | Description |
+| -- | -- |
+| `.toVar( node, name = null )` or `Var( node, name = null )` | Converts a node into a reusable variable in the shader. |
+| `.toConst( node, name = null )` or `Const( node, name = null )` | Converts a node into an inline constant. |
+| `property( type, name = null )` | Declares an property but does not assign an initial value. |
+
+The name is optional; if set to `null`, the node system will generate one automatically.
+Creating a variable, constant, or property can help optimize the shader graph manually or assist in debugging.
+
+```js
+const uvScaled = uv().mul( 10 ).toVar();
+
+material.colorNode = texture( map, uvScaled );
+```
+
+***
+
+## Array
+
+The array() function in TSL allows creating constant or dynamic value arrays; there are many ways to create arrays in TSL.
+
+#### The standard way
+
+```js
+const colors = array( [
+ vec3( 1, 0, 0 ),
+ vec3( 0, 1, 0 ),
+ vec3( 0, 0, 1 )
+] );
+
+const greenColor = colors.element( 1 );
+
+// greenColor: vec3( 0, 1, 0 )
+```
+
+#### Fixed size
+
+```js
+const a = array( 'vec3', 2 );
+
+// a: [ vec3( 0, 0, 0 ), vec3( 0, 0, 0 ) ]
+```
+
+#### Fill with a default value
+
+```js
+const a = vec3( 0, 0, 1 ).toArray( 2 );
+
+// a: [ vec3( 0, 0, 1 ), vec3( 0, 0, 1 ) ]
+```
+
+#### Define a type explicitly
+
+```js
+const a = array( [ 0, 1, 2 ], 'uint' );
+const value = a.element( 1 );
+
+// value: 1u
+```
+
+### Array Uniform
+
+It is possible to use the same array logic for uniforms using Three.js native components or primitive values.
+
+```js
+const tintColors = uniformArray( [
+ new Color( 1, 0, 0 ),
+ new Color( 0, 1, 0 ),
+ new Color( 0, 0, 1 )
+], 'color' );
+
+const redColor = tintColors.element( 0 );
+```
+
+#### Accessing values
+
+To access the values you can use `a[ 1 ]` or `a.element( 1 )`. The difference is that `a[ 1 ]` only allows constant values, while `a.element( 1 )` allows the use of dynamic values such as `a.element( index )` where index is a node.
+
+### Array Storage
+
+It is possible to create arrays that can be used in compute shaders and storage operations.
+
+| Name | Description |
+| -- | -- |
+| `instancedArray( array, type )` | Creates an instanced buffer attribute array. |
+| `attributeArray( array, type )` | Creates a buffer attribute array. |
+
+## Varying
+
+Functions used to declare varying.
+
+| Name | Description |
+| -- | -- |
+| `vertexStage( node )` | Computes the node in the vertex stage. |
+| `varying( node, name = null )` | Computes the node in the vertex stage and passes interpolated values to the fragment shader. |
+| `varyingProperty( type, name = null )` | Declares an varying property but does not assign an initial value. |
+
+Let's suppose you want to optimize some calculation in the `vertex stage` but are using it in a slot like `material.colorNode`.
+
+For example:
+
+```js
+// multiplication will be executed in vertex stage
+const normalView = vertexStage( modelNormalMatrix.mul( normalLocal ) );
+
+// normalize will be computed in fragment stage while `normalView` is computed on vertex stage
+material.colorNode = normalView.normalize();
+```
+
+The first parameter of `vertexStage()` `modelNormalMatrix.mul( normalLocal )` will be computed in `vertex stage`, and the return from `vertexStage()` will be a `varying` as we are used in WGSL/GLSL, this can optimize extra calculations in the `fragment stage`. The second parameter of `varying()` allows you to add a custom name in code generation.
+
+If `varying()` is added only to `material.positionNode`, it will only return a simple variable and varying will not be created because `material.positionNode` is one of the only node material input that are computed at the vertex stage.
+
+## Conditional
+
+### If-else
+
+`If-else` conditionals can be used within `Fn()`. Conditionals in `TSL` are built using the `If` function:
+
+```js
+If( conditional, function )
+.ElseIf( conditional, function )
+.Else( function )
+```
+> Notice here the `i` in `If` is capitalized.
+
+Example:
+
+In this example below, we will limit the y position of the geometry to 10.
+
+```js
+const limitPosition = Fn( ( { position } ) => {
+
+ const limit = 10;
+
+ const result = vec3( position );
+
+ If( result.y.greaterThan( limit ), () => {
+
+ result.y = limit;
+
+ } );
+
+ return result;
+
+} );
+
+material.positionNode = limitPosition( { position: positionLocal } );
+```
+
+Example using `elseif`:
+
+```js
+const limitPosition = Fn( ( { position } ) => {
+
+ const limit = 10;
+
+ const result = vec3( position );
+
+ If( result.y.greaterThan( limit ), () => {
+
+ result.y = limit;
+
+ } ).ElseIf( result.y.lessThan( limit ), () => {
+
+ result.y = limit;
+
+ } );
+
+ return result;
+
+} );
+
+material.positionNode = limitPosition( { position: positionLocal } );
+```
+### Switch-Case
+
+A Switch-Case statement is an alternative way to express conditional logic compared to If-Else.
+
+```js
+const col = color();
+
+Switch( 0 )
+ .Case( 0, () => {
+
+ col.assign( color( 1, 0, 0 ) );
+
+ } ).Case( 1, () => {
+
+ col.assign( color( 0, 1, 0 ) );
+
+ } ).Case( 2, 3, () => {
+
+ col.assign( color( 0, 0, 1 ) );
+
+ } ).Default( () => {
+
+ col.assign( color( 1, 1, 1 ) );
+
+ } );
+```
+Notice that there are some rules when using this syntax which differentiate TSL from JavaScript:
+
+- There is no fallthrough support. So each `Case()` statement has an implicit break.
+- A `Case()` statement can hold multiple values (selectors) for testing.
+
+### Ternary
+
+Different from `if-else`, a ternary conditional will return a value and can be used outside of `Fn()`.
+
+```js
+const result = select( value.greaterThan( 1 ), 1.0, value );
+```
+> Equivalent in JavaScript should be: `value > 1 ? 1.0 : value`
+
+## Loop
+
+This module offers a variety of ways to implement loops in TSL. In it's basic form it's:
+```js
+Loop( count, ( { i } ) => {
+
+} );
+```
+However, it is also possible to define a start and end ranges, data types and loop conditions:
+```js
+Loop( { start: int( 0 ), end: int( 10 ), type: 'int', condition: '<', name: 'i' }, ( { i } ) => {
+
+} );
+```
+Nested loops can be defined in a compacted form:
+```js
+Loop( 10, 5, ( { i, j } ) => {
+
+} );
+```
+Loops that should run backwards can be defined like so:
+```js
+Loop( { start: 10 }, () => {} );
+```
+It is possible to execute with boolean values, similar to the `while` syntax.
+```js
+const value = float( 0 );
+
+Loop( value.lessThan( 10 ), () => {
+
+ value.addAssign( 1 );
+
+} );
+```
+The module also provides `Break()` and `Continue()` TSL expression for loop control.
+
+## Math
+
+| Name | Description |
+| -- | -- |
+| `EPSILON` | A small value used to handle floating-point precision errors. |
+| `INFINITY` | Represent infinity. |
+| `PI` | The mathematical constant π (pi). |
+| `TWO_PI` | Two times π (2π). |
+| `HALF_PI` | Half of π (π/2). |
+| | |
+| `abs( x )` | Return the absolute value of the parameter. |
+| `acos( x )` | Return the arccosine of the parameter. |
+| `all( x )` | Return true if all components of x are true. |
+| `any( x )` | Return true if any component of x is true. |
+| `asin( x )` | Return the arcsine of the parameter. |
+| `atan( y, x )` | Return the arc-tangent of the parameters. |
+| `bitcast( x, y )` | Reinterpret the bits of a value as a different type. |
+| `cbrt( x )` | Return the cube root of the parameter. |
+| `ceil( x )` | Find the nearest integer that is greater than or equal to the parameter. |
+| `clamp( x, min, max )` | Constrain a value to lie between two further values. |
+| `cos( x )` | Return the cosine of the parameter. |
+| `cross( x, y )` | Calculate the cross product of two vectors. |
+| `dFdx( p )` | Return the partial derivative of an argument with respect to x. |
+| `dFdy( p )` | Return the partial derivative of an argument with respect to y. |
+| `degrees( radians )` | Convert a quantity in radians to degrees. |
+| `difference( x, y )` | Calculate the absolute difference between two values. |
+| `distance( x, y )` | Calculate the distance between two points. |
+| `dot( x, y )` | Calculate the dot product of two vectors. |
+| `equals( x, y )` | Return true if x equals y. |
+| `exp( x )` | Return the natural exponentiation of the parameter. |
+| `exp2( x )` | Return 2 raised to the power of the parameter. |
+| `faceforward( N, I, Nref )` | Return a vector pointing in the same direction as another. |
+| `floor( x )` | Find the nearest integer less than or equal to the parameter. |
+| `fract( x )` | Compute the fractional part of the argument. |
+| `fwidth( x )` | Return the sum of the absolute derivatives in x and y. |
+| `inverseSqrt( x )` | Return the inverse of the square root of the parameter. |
+| `length( x )` | Calculate the length of a vector. |
+| `lengthSq( x )` | Calculate the squared length of a vector. |
+| `log( x )` | Return the natural logarithm of the parameter. |
+| `log2( x )` | Return the base 2 logarithm of the parameter. |
+| `max( x, y )` | Return the greater of two values. |
+| `min( x, y )` | Return the lesser of two values. |
+| `mix( x, y, a )` | Linearly interpolate between two values. |
+| `negate( x )` | Negate the value of the parameter ( -x ). |
+| `normalize( x )` | Calculate the unit vector in the same direction as the original vector. |
+| `oneMinus( x )` | Return 1 minus the parameter. |
+| `pow( x, y )` | Return the value of the first parameter raised to the power of the second. |
+| `pow2( x )` | Return the square of the parameter. |
+| `pow3( x )` | Return the cube of the parameter. |
+| `pow4( x )` | Return the fourth power of the parameter. |
+| `radians( degrees )` | Convert a quantity in degrees to radians. |
+| `reciprocal( x )` | Return the reciprocal of the parameter (1/x). |
+| `reflect( I, N )` | Calculate the reflection direction for an incident vector. |
+| `refract( I, N, eta )` | Calculate the refraction direction for an incident vector. |
+| `round( x )` | Round the parameter to the nearest integer. |
+| `saturate( x )` | Constrain a value between 0 and 1. |
+| `sign( x )` | Extract the sign of the parameter. |
+| `sin( x )` | Return the sine of the parameter. |
+| `smoothstep( e0, e1, x )` | Perform Hermite interpolation between two values. |
+| `sqrt( x )` | Return the square root of the parameter. |
+| `step( edge, x )` | Generate a step function by comparing two values. |
+| `tan( x )` | Return the tangent of the parameter. |
+| `transformDirection( dir, matrix )` | Transform the direction of a vector by a matrix and then normalize the result. |
+| `trunc( x )` | Truncate the parameter, removing the fractional part. |
+
+```js
+const value = float( -1 );
+
+// It's possible use `value.abs()` too.
+const positiveValue = abs( value ); // output: 1
+```
+
+## Method chaining
+
+`Method chaining` will only be including operators, converters, math and some core functions. These functions, however, can be used on any `node`.
+
+Example:
+
+`oneMinus()` is a mathematical function like `abs()`, `sin()`. This example uses `.oneMinus()` as a built-in function in the class that returns a new node instead of classic C function like `oneMinus( texture( map ).rgb )`.
+
+```js
+// it will invert the texture color
+material.colorNode = texture( map ).rgb.oneMinus();
+```
+
+You can use mathematical operators on any node, e.g:
+
+```js
+const contrast = .5;
+const brightness = .5;
+
+material.colorNode = texture( map ).mul( contrast ).add( brightness );
+```
+
+## Texture
+
+| Name | Description | Type |
+| -- | -- | -- |
+| `texture( texture, uv = uv(), level = null )` | Retrieves texels from a texture. | `vec4` |
+| `textureLoad( texture, uv, level = null )` | Fetches/loads texels without interpolation. | `vec4` |
+| `textureStore( texture, uv, value )` | Stores a value into a storage texture. | `void` |
+| `textureSize( texture, level = null )` | Returns the size of a texture. | `ivec2` |
+| `textureBicubic( textureNode, strength = null )` | Applies mipped bicubic texture filtering. | `vec4` |
+| `cubeTexture( texture, uvw = reflectVector, level = null )` | Retrieves texels from a cube texture. | `vec4` |
+| `texture3D( texture, uvw = null, level = null )` | Retrieves texels from a 3D texture. | `vec4` |
+| `triplanarTexture( textureX, textureY = null, textureZ = null, scale = float( 1 ), position = positionLocal, normal = normalLocal )` | Computes texture using triplanar mapping based on provided parameters. | `vec4` |
+
+## Attributes
+
+| Name | Description | Type |
+| -- | -- | -- |
+| `attribute( name, type = null )` | Getting geometry attribute using name and type. | `any` |
+| `uv( index = 0 )` | UV attribute named `uv + index`. | `vec2` |
+| `vertexColor( index = 0 )` | Vertex color node for the specified index. | `color` |
+| `instanceIndex` | The index of the current instance. | `uint` |
+| `vertexIndex` | The index of a vertex within a mesh. | `uint` |
+| `drawIndex` | The draw index when using multi-draw. | `uint` |
+| `batch( batchMesh )` | Creates a batch node for BatchedMesh. | `BatchNode` |
+| `instance( instancedMesh )` | Creates an instance node for InstancedMesh. | `InstanceNode` |
+
+## Position
+
+The transformed term reflects the modifications applied by processes such as `skinning`, `morphing`, and similar techniques.
+
+| Name | Description | Type |
+| -- | -- | -- |
+| `positionGeometry` | Position attribute of geometry. | `vec3` |
+| `positionLocal` | Transformed local position. | `vec3` |
+| `positionWorld` | Transformed world position. | `vec3` |
+| `positionWorldDirection` | Normalized world direction. | `vec3` |
+| `positionView` | View position. | `vec3` |
+| `positionViewDirection` | Normalized view direction. | `vec3` |
+
+## Normal
+
+The term transformed here also includes following the correct orientation of the face, so that the normals are inverted inside the geometry.
+
+| Name | Description | Type |
+| -- | -- | -- |
+| `normalGeometry` | Normal attribute of geometry. | `vec3` |
+| `normalLocal` | Local variable for normal. | `vec3` |
+| `normalView` | Normalized transformed view normal. | `vec3` |
+| `normalViewGeometry` | Normalized view normal. | `vec3` |
+| `normalWorld` | Normalized transformed world normal. | `vec3` |
+| `normalWorldGeometry` | Normalized world normal. | `vec3` |
+
+## Tangent
+
+| Name | Description | Type |
+| -- | -- | -- |
+| `tangentGeometry` | Tangent attribute of geometry. | `vec4` |
+| `tangentLocal` | Local variable for tangent. | `vec3` |
+| `tangentView` | Normalized transformed view tangent. | `vec3` |
+| `tangentWorld` | Normalized transformed world tangent. | `vec3` |
+
+### Bitangent
+
+| Name | Description | Type |
+| -- | -- | -- |
+| `bitangentGeometry` | Normalized bitangent in geometry space. | `vec3` |
+| `bitangentLocal` | Normalized bitangent in local space. | `vec3` |
+| `bitangentView` | Normalized transformed bitangent in view space. | `vec3` |
+| `bitangentWorld` | Normalized transformed bitangent in world space. | `vec3` |
+
+## Camera
+
+| Name | Description | Type |
+| -- | -- | -- |
+| `cameraNear` | Near plane distance of the camera. | `float` |
+| `cameraFar` | Far plane distance of the camera. | `float` |
+| `cameraProjectionMatrix` | Projection matrix of the camera. | `mat4` |
+| `cameraProjectionMatrixInverse` | Inverse projection matrix of the camera. | `mat4` |
+| `cameraViewMatrix` | View matrix of the camera. | `mat4` |
+| `cameraWorldMatrix` | World matrix of the camera. | `mat4` |
+| `cameraNormalMatrix` | Normal matrix of the camera. | `mat3` |
+| `cameraPosition` | World position of the camera. | `vec3` |
+
+## Model
+
+| Name | Description | Type |
+| -- | -- | -- |
+| `modelDirection` | Direction of the model. | `vec3` |
+| `modelViewMatrix` | View-space matrix of the model. | `mat4` |
+| `modelNormalMatrix` | View-space matrix of the model. | `mat3` |
+| `modelWorldMatrix` | World-space matrix of the model. | `mat4` |
+| `modelPosition` | Position of the model. | `vec3` |
+| `modelScale` | Scale of the model. | `vec3` |
+| `modelViewPosition` | View-space position of the model. | `vec3` |
+| `modelWorldMatrixInverse` | Inverse world matrix of the model. | `mat4` |
+| | |
+| `highpModelViewMatrix` | View-space matrix of the model computed on CPU using 64-bit. | `mat4` |
+| `highpModelNormalViewMatrix` | View-space normal matrix of the model computed on CPU using 64-bit. | `mat3` |
+
+## Screen
+
+Screen nodes will return the values related to the current `frame buffer`, either normalized or in `physical pixel units` considering the current `Pixel Ratio`.
+
+| Variable | Description | Type |
+| -- | -- | -- |
+| `screenUV` | Returns the normalized frame buffer coordinate. | `vec2` |
+| `screenCoordinate` | Returns the frame buffer coordinate in physical pixel units. | `vec2` |
+| `screenSize` | Returns the frame buffer size in physical pixel units. | `vec2` |
+| `screenDPR` | Returns the device pixel ratio (DPR). | `float` |
+
+## Viewport
+
+`viewport` is influenced by the area defined in `renderer.setViewport()`, different of the values defined in the renderer that are `logical pixel units`, it use `physical pixel units` considering the current `Pixel Ratio`.
+
+| Variable | Description | Type |
+| -- | -- | -- |
+| `viewportUV` | Returns the normalized viewport coordinate. | `vec2` |
+| `viewport` | Returns the viewport dimension in physical pixel units. | `vec4` |
+| `viewportCoordinate` | Returns the viewport coordinate in physical pixel units. | `vec2` |
+| `viewportSize` | Returns the viewport size in physical pixel units. | `vec2` |
+| `viewportSharedTexture( uvNode = screenUV, levelNode = null )` | Accesses what has already been rendered, preserving render-order. | `vec4` |
+| `viewportDepthTexture( uvNode = screenUV, levelNode = null )` | Returns the depth texture of the viewport. | `float` |
+| `viewportLinearDepth` | Returns the linear (orthographic) depth value of the current fragment. | `float` |
+| `viewportMipTexture( uvNode = screenUV, levelNode = null, framebufferTexture = null )` | Returns a viewport texture with mipmap generation enabled. | `vec4` |
+| `viewportSafeUV( uv = screenUV )` | Returns safe UV coordinates for refraction purposes. | `vec2` |
+
+## Blend Modes
+
+| Variable | Description | Type |
+| -- | -- | -- |
+| `blendBurn( a, b )` | Returns the burn blend mode. | `color` |
+| `blendDodge( a, b )` | Returns the dodge blend mode. | `color` |
+| `blendOverlay( a, b )` | Returns the overlay blend mode. | `color` |
+| `blendScreen( a, b )` | Returns the screen blend mode. | `color` |
+| `blendColor( a, b )` | Returns the (normal) color blend mode. | `color` |
+
+## Reflect
+
+| Name | Description | Type |
+| -- | -- | -- |
+| `reflectView` | Computes reflection direction in view space. | `vec3` |
+| `reflectVector` | Transforms the reflection direction to world space. | `vec3` |
+
+## UV Utils
+
+| Name | Description | Type |
+| -- | -- | -- |
+| `matcapUV` | UV coordinates for matcap texture. | `vec2` |
+| `rotateUV( uv, rotation, centerNode = vec2( 0.5 ) )` | Rotates UV coordinates around a center point. | `vec2` |
+| `spherizeUV( uv, strength, centerNode = vec2( 0.5 ) )` | Distorts UV coordinates with a spherical effect around a center point. | `vec2` |
+| `spritesheetUV( count, uv = uv(), frame = float( 0 ) )` | Computes UV coordinates for a sprite sheet based on the number of frames, UV coordinates, and frame index. | `vec2` |
+| `equirectUV( direction = positionWorldDirection )` | Computes UV coordinates for equirectangular mapping based on the direction vector. | `vec2` |
+
+```js
+import { texture, matcapUV } from 'three/tsl';
+
+const matcap = texture( matcapMap, matcapUV );
+```
+
+## Interpolation
+
+| Variable | Description | Type |
+| -- | -- | -- |
+| `remap( node, inLow, inHigh, outLow = float( 0 ), outHigh = float( 1 ) )` | Remaps a value from one range to another. | `any` |
+| `remapClamp( node, inLow, inHigh, outLow = float( 0 ), outHigh = float( 1 ) )` | Remaps a value from one range to another, with clamping. | `any` |
+
+## Random
+
+| Variable | Description | Type |
+| -- | -- | -- |
+| `hash( seed )` | Generates a hash value in the range [ 0, 1 ] from the given seed. | `float` |
+| `range( min, max )` | Generates a range `attribute` of values between min and max. Attribute randomization is useful when you want to randomize values between instances and not between pixels. | `any` |
+
+## Rotate
+
+| Name | Description | Type |
+| -- | -- | -- |
+| `rotate( position, rotation )` | Applies a rotation to the given position node. Depending on whether the position data are 2D or 3D, the rotation is expressed a single float value or an Euler value. | `vec2`, `vec3`
+
+## Oscillator
+
+| Variable | Description | Type |
+| -- | -- | -- |
+| `oscSine( timer = time )` | Generates a sine wave oscillation based on a timer. | `float` |
+| `oscSquare( timer = time )` | Generates a square wave oscillation based on a timer. | `float` |
+| `oscTriangle( timer = time )` | Generates a triangle wave oscillation based on a timer. | `float` |
+| `oscSawtooth( timer = time )` | Generates a sawtooth wave oscillation based on a timer. | `float` |
+
+## Timer
+
+| Variable | Description | Type |
+| -- | -- | -- |
+| `time` | Represents the elapsed time in seconds. | `float` |
+| `deltaTime` | Represents the delta time in seconds. | `float` |
+
+## Packing
+
+| Variable | Description | Type |
+| -- | -- | -- |
+| `directionToColor( value )` | Converts direction vector to color. | `color` |
+| `colorToDirection( value )` | Converts color to direction vector. | `vec3` |
+
+## Post-Processing
+
+TSL utilities for post-processing effects. They can be used in materials or post-processing passes.
+
+| Name | Description |
+| -- | -- |
+| `afterImage( node, damp = 0.96 )` | Creates an after image effect. |
+| `anamorphic( node, threshold = 0.9, scale = 3, samples = 32 )` | Creates an anamorphic flare effect. |
+| `bloom( node, strength = 1, radius = 0, threshold = 0 )` | Creates a bloom effect. |
+| `boxBlur( textureNode, options = {} )` | Applies a box blur effect. |
+| `chromaticAberration( node, strength = 1.0, center = null, scale = 1.1 )` | Creates a chromatic aberration effect. |
+| `denoise( node, depthNode, normalNode, camera )` | Creates a denoise effect. |
+| `dof( node, viewZNode, focusDistance, focalLength, bokehScale )` | Creates a depth-of-field effect. |
+| `dotScreen( node, angle = 1.57, scale = 1 )` | Creates a dot-screen effect. |
+| `film( inputNode, intensityNode = null, uvNode = null )` | Creates a film grain effect. |
+| `fxaa( node )` | Creates a FXAA anti-aliasing effect. |
+| `gaussianBlur( node, directionNode, sigma, options = {} )` | Creates a gaussian blur effect. |
+| `grayscale( color )` | Converts color to grayscale. |
+| `hashBlur( textureNode, bluramount = float( 0.1 ), options = {} )` | Applies a hash blur effect. |
+| `lut3D( node, lut, size, intensity )` | Creates a LUT color grading effect. |
+| `motionBlur( inputNode, velocity, numSamples = int( 16 ) )` | Creates a motion blur effect. |
+| `outline( scene, camera, params )` | Creates an outline effect around selected objects. |
+| `rgbShift( node, amount = 0.005, angle = 0 )` | Creates an RGB shift effect. |
+| `sepia( color )` | Applies a sepia effect. |
+| `smaa( node )` | Creates a SMAA anti-aliasing effect. |
+| `sobel( node )` | Creates a sobel edge detection effect. |
+| `ssr( colorNode, depthNode, normalNode, metalnessNode, roughnessNode = null, camera = null )` | Creates screen space reflections. |
+| `ssgi( beautyNode, depthNode, normalNode, camera )` | Creates a SSGI effect. |
+| `ao( depthNode, normalNode, camera )` | Creates a Ground Truth Ambient Occlusion (GTAO) effect. |
+| `transition( nodeA, nodeB, mixTextureNode, mixRatio, threshold, useTexture )` | Creates a transition effect between two scenes. |
+| `traa( beautyNode, depthNode, velocityNode, camera )` | Creates a TRAA temporal anti-aliasing effect. |
+
+Example:
+
+```js
+import { gaussianBlur, grayscale, pass } from 'three/tsl';
+
+// Post-processing
+const scenePass = pass( scene, camera );
+const beauty = scenePass.getTextureNode();
+
+postProcessing.outputNode = grayscale( gaussianBlur( beauty, 4 ) );
+```
+
+## Render Pass
+
+Functions for creating and managing render passes.
+
+| Name | Description |
+| -- | -- |
+| `pass( scene, camera, options = {} )` | Creates a pass node for rendering a scene. |
+| `passTexture( pass, texture )` | Creates a pass texture node. |
+| `depthPass( scene, camera, options = {} )` | Creates a depth pass node. |
+| `mrt( outputNodes )` | Creates a Multiple Render Targets (MRT) node. |
+| `renderOutput( node, targetColorSpace, targetToneMapping )` | Creates a render output node. |
+
+Example:
+
+```js
+import { pass, mrt, output, emissive } from 'three/tsl';
+
+const scenePass = pass( scene, camera );
+
+// Setup MRT
+scenePass.setMRT( mrt( {
+ output: output,
+ emissive: emissive
+} ) );
+
+const outputNode = scenePass.getTextureNode( 'output' );
+const emissiveNode = scenePass.getTextureNode( 'emissive' );
+```
+
+## Compute
+
+Compute shaders allow general-purpose GPU computations. TSL provides functions for creating and managing compute operations.
+
+| Name | Description |
+| -- | -- |
+| `compute( node, count = null, workgroupSize = [ 64 ] )` | Creates a compute node. |
+| `atomicAdd( node, value )` | Performs an atomic addition. |
+| `atomicSub( node, value )` | Performs an atomic subtraction. |
+| `atomicMax( node, value )` | Performs an atomic max operation. |
+| `atomicMin( node, value )` | Performs an atomic min operation. |
+| `atomicAnd( node, value )` | Performs an atomic AND operation. |
+| `atomicOr( node, value )` | Performs an atomic OR operation. |
+| `atomicXor( node, value )` | Performs an atomic XOR operation. |
+| `atomicStore( node, value )` | Stores a value atomically. |
+| `atomicLoad( node )` | Loads a value atomically. |
+| `workgroupBarrier()` | Creates a workgroup barrier. |
+| `storageBarrier()` | Creates a storage barrier. |
+| `textureBarrier()` | Creates a texture barrier. |
+| `barrier()` | Creates a memory barrier. |
+| `workgroupId` | The workgroup ID. |
+| `localId` | The local invocation ID within the workgroup. |
+| `globalId` | The global invocation ID. |
+| `numWorkgroups` | The number of workgroups. |
+| `subgroupSize` | The size of the subgroup. |
+
+Example:
+
+```js
+import { Fn, instancedArray, instanceIndex, deltaTime } from 'three/tsl';
+
+const count = 1000;
+const positionArray = instancedArray( count, 'vec3' );
+
+// create a compute function
+
+const computeShader = Fn( () => {
+
+ const position = positionArray.element( instanceIndex );
+
+ position.x.addAssign( deltaTime );
+
+} )().compute( count );
+
+//
+
+renderer.compute( computeShader );
+```
+
+## Storage
+
+Storage functions allow reading and writing to GPU buffers.
+
+| Name | Description |
+| -- | -- |
+| `storage( attribute, type, count )` | Creates a storage buffer. |
+| `storageTexture( texture )` | Creates a storage texture for read/write operations. |
+
+## Struct
+
+Structs allow you to create custom data types with multiple members. They can be used to organize related data in shaders, define structures for attributes and uniforms.
+
+| Name | Description |
+| -- | -- |
+| `struct( membersLayout, name = null )` | Creates a struct type with the specified member layout. |
+| `outputStruct( ...members )` | Creates an output struct node for returning multiple values. |
+
+Example:
+
+```js
+import { struct, vec3 } from 'three/tsl';
+
+// Define a custom struct
+const BoundingBox = struct( { min: 'vec3', max: 'vec3' } );
+
+// Create a new instance of the struct
+const bb = BoundingBox( vec3( 0 ), vec3( 1 ) ); // style 1
+const bb2 = BoundingBox( { min: vec3( 0 ), max: vec3( 1 ) } ); // style 2
+
+// Access the struct members
+const min = bb.get( 'min' );
+
+// Assign a new value to a member
+min.assign( vec3( -1, -1, -1 ) );
+```
+
+## Flow Control
+
+Functions for controlling shader flow.
+
+| Name | Description |
+| -- | -- |
+| `Discard()` | Discards the current fragment. |
+| `Return()` | Returns from the current function. |
+| `Break()` | Breaks out of a loop. |
+| `Continue()` | Continues to the next iteration of a loop. |
+
+Example:
+
+```js
+import { Fn, If, Discard, uv } from 'three/tsl';
+
+const customFragment = Fn( () => {
+
+ If( uv().x.lessThan( 0.5 ), () => {
+
+ Discard();
+
+ } );
+
+ return vec4( 1, 0, 0, 1 );
+
+} );
+
+material.colorNode = customFragment();
+```
+
+## Fog
+
+Functions for creating fog effects in the scene. Assign the fog node to `scene.fogNode`.
+
+| Name | Description | Type |
+| -- | -- | -- |
+| `fog( color, factor )` | Creates a fog node with specified color and fog factor. | `FogNode` |
+| `rangeFogFactor( near, far )` | Creates a linear fog factor based on distance from camera. | `float` |
+| `densityFogFactor( density )` | Creates an exponential squared fog factor for denser fog. | `float` |
+
+Example:
+
+```js
+import { fog, rangeFogFactor, densityFogFactor, color } from 'three/tsl';
+
+// Linear fog (starts at 10 units, fully opaque at 100 units)
+scene.fogNode = fog( color( 0x000000 ), rangeFogFactor( 10, 100 ) );
+
+// Exponential fog (density-based)
+scene.fogNode = fog( color( 0xcccccc ), densityFogFactor( 0.02 ) );
+```
+
+## Color Adjustments
+
+Functions for adjusting and manipulating colors.
+
+| Name | Description | Type |
+| -- | -- | -- |
+| `luminance( node )` | Calculates the luminance (perceived brightness) of a color. | `float` |
+| `saturation( node, adjustment = 1 )` | Adjusts the saturation of a color. Values > 1 increase saturation, < 1 decrease. | `color` |
+| `vibrance( node, adjustment = 1 )` | Selectively enhances less saturated colors while preserving already saturated ones. | `color` |
+| `hue( node, adjustment = 0 )` | Rotates the hue of a color. Value is in radians. | `color` |
+| `posterize( node, steps )` | Reduces the number of color levels, creating a poster-like effect. | `color` |
+
+Example:
+
+```js
+import { texture, saturation, hue, posterize } from 'three/tsl';
+
+// Increase saturation
+material.colorNode = saturation( texture( map ), 1.5 );
+
+// Rotate hue by 90 degrees
+material.colorNode = hue( texture( map ), Math.PI / 2 );
+
+// Posterize to 4 color levels
+material.colorNode = posterize( texture( map ), 4 );
+```
+
+## Utilities
+
+Utility functions for common shader tasks.
+
+| Name | Description | Type |
+| -- | -- | -- |
+| `billboarding( { position, horizontal, vertical } )` | Orients flat meshes always towards the camera. `position`: vertex positions in world space (default: `null`). `horizontal`: follow camera horizontally (default: `true`). `vertical`: follow camera vertically (default: `false`). | `vec3` |
+| `checker( coord )` | Creates a 2x2 checkerboard pattern. | `float` |
+
+Example:
+
+```js
+import { billboarding } from 'three/tsl';
+
+// Full billboarding (like particles) - faces camera in all directions
+material.vertexNode = billboarding();
+
+// Horizontal only (like trees) - rotates around Y axis only
+material.vertexNode = billboarding( { horizontal: true, vertical: false } );
+```
+
+## NodeMaterial
+
+Check below for more details about `NodeMaterial` inputs.
+
+#### Core
+
+| Name | Description | Type |
+|--|--|--|
+| `.fragmentNode` | Replaces the built-in material logic used in the fragment stage. | `vec4` |
+| `.vertexNode` | Replaces the built-in material logic used in the vertex stage. | `vec4` |
+| `.geometryNode` | Allows you to execute a TSL function to deal with Geometry. | `Fn()` |
+
+#### Basic
+
+| Name | Description | Reference | Type |
+|--|--|--|--|
+| `.colorNode` | Replace the logic of `material.color * material.map`. | `materialColor` | `vec4` |
+| `.depthNode` | Customize the `depth` output. | `depth` | `float` |
+| `.opacityNode` | Replace the logic of `material.opacity * material.alphaMap`. | `materialOpacity` | `float` |
+| `.alphaTestNode` | Sets a threshold to discard pixels with low opacity. | `materialAlphaTest` | `float` |
+| `.positionNode` | Represents the vertex positions in local-space. Replace the logic of `material.displacementMap * material.displacementScale + material.displacementBias`. | `positionLocal` | `vec3` |
+
+#### Lighting
+
+| Name | Description | Reference | Type |
+|--|--|--|--|
+| `.emissiveNode` | Replace the logic of `material.emissive * material.emissiveIntensity * material.emissiveMap`. | `materialEmissive` | `color` |
+| `.normalNode` | Represents the normals direction in view-space. Replace the logic of `material.normalMap * material.normalScale` and `material.bumpMap * material.bumpScale`. | `materialNormal` | `vec3` |
+| `.lightsNode` | Defines the lights and lighting model that will be used by the material. | | `lights()` |
+| `.envNode` | Replace the logic of `material.envMap * material.envMapRotation * material.envMapIntensity`. | | `color` |
+
+#### Backdrop
+
+| Name | Description | Type |
+|--|--|--|
+| `.backdropNode` | Set the current render color to be used before applying `Specular`, useful for `transmission` and `refraction` effects. | `color` |
+| `.backdropAlphaNode` | Define the alpha of `backdropNode`. | `float` |
+
+#### Shadows
+
+| Name | Description | Reference | Type |
+|--|--|--|--|
+| `.castShadowNode` | Control the `color` and `opacity` of the shadow that will be projected by the material. | | `vec4` |
+| `.maskShadowNode` | Define a custom mask for the shadow. | | `bool` |
+| `.receivedShadowNode` | Handle the shadow cast on the material. | | `Fn()` |
+| `.receivedShadowPositionNode` | Define the shadow projection position in world-space. | `shadowPositionWorld` | `vec3` |
+| `.aoNode` | Replace the logic of `material.aoMap * aoMapIntensity`. | `materialAO` | `float` |
+
+#### Output
+
+| Name | Description | Reference | Type |
+|--|--|--|--|
+| `.maskNode` | Define the material's mask. Unlike opacity, it is discarded at the beginning of rendering, optimizing the process. | | `bool` |
+| `.mrtNode` | Define a different MRT than the one defined in `pass()`. | | `mrt()` |
+| `.outputNode` | Defines the material's final output. | `output` | `vec4` |
+
+## LineDashedNodeMaterial
+
+| Name | Description | Reference | Type |
+|--|--|--|--|
+| `.dashScaleNode` | Replace the logic of `material.scale`. | `materialLineScale` | `float` |
+| `.dashSizeNode` | Replace the logic of `material.dashSize`. | `materialLineDashSize` | `float` |
+| `.gapSizeNode` | Replace the logic of `material.gapSize`. | `materialLineGapSize` | `float` |
+| `.offsetNode` | Replace the logic of `material.dashOffset`. | `materialLineDashOffset` | `float` |
+
+## MeshPhongNodeMaterial
+
+| Name | Description | Reference | Type |
+|--|--|--|--|
+| `.shininessNode` | Replace the logic of `material.shininess`. | `materialShininess` | `float` |
+| `.specularNode` | Replace the logic of `material.specular`. | `materialSpecular` | `color` |
+
+## MeshStandardNodeMaterial
+
+| Name | Description | Reference | Type |
+|--|--|--|--|
+| `.metalnessNode` | Replace the logic of `material.metalness * material.metalnessMap`. | `materialMetalness` | `float` |
+| `.roughnessNode` | Replace the logic of `material.roughness * material.roughnessMap`. | `materialRoughness` | `float` |
+
+## MeshPhysicalNodeMaterial
+
+| Name | Description | Reference | Type |
+|--|--|--|--|
+| `.clearcoatNode` | Replace the logic of `material.clearcoat * material.clearcoatMap`. | `materialClearcoat` | `float` |
+| `.clearcoatRoughnessNode` | Replace the logic of `material.clearcoatRoughness * material.clearcoatRoughnessMap`. | `materialClearcoatRoughness` | `float` |
+| `.clearcoatNormalNode` | Replace the logic of `material.clearcoatNormalMap * material.clearcoatNormalMapScale`. | `materialClearcoatNormal` | `vec3` |
+| `.sheenNode` | Replace the logic of `material.sheenColor * material.sheenColorMap`. | `materialSheen` | `color` |
+| `.iridescenceNode` | Replace the logic of `material.iridescence`. | `materialIridescence` | `float` |
+| `.iridescenceIORNode` | Replace the logic of `material.iridescenceIOR`. | `materialIridescenceIOR` | `float` |
+| `.iridescenceThicknessNode` | Replace the logic of `material.iridescenceThicknessRange * material.iridescenceThicknessMap`. | `materialIridescenceThickness` | `float` |
+| `.specularIntensityNode` | Replace the logic of `material.specularIntensity * material.specularIntensityMap`. | `materialSpecularIntensity` | `float` |
+| `.specularColorNode` | Replace the logic of `material.specularColor * material.specularColorMap`. | `materialSpecularColor` | `color` |
+| `.iorNode` | Replace the logic of `material.ior`. | `materialIOR` | `float` |
+| `.transmissionNode` | Replace the logic of `material.transmission * material.transmissionMap`. | `materialTransmission` | `color` |
+| `.thicknessNode` | Replace the logic of `material.thickness * material.thicknessMap`. | `materialTransmission` | `float` |
+| `.attenuationDistanceNode` | Replace the logic of `material.attenuationDistance`. | `materialAttenuationDistance` | `float` |
+| `.attenuationColorNode` | Replace the logic of `material.attenuationColor`. | `materialAttenuationColor` | `color` |
+| `.dispersionNode` | Replace the logic of `material.dispersion`. | `materialDispersion` | `float` |
+| `.anisotropyNode` | Replace the logic of `material.anisotropy * material.anisotropyMap`. | `materialAnisotropy` | `vec2` |
+
+## SpriteNodeMaterial
+
+| Name | Description | Type |
+|--|--|--|
+| `.positionNode` | Defines the position. | `vec3` |
+| `.rotationNode` | Defines the rotation. | `float` |
+| `.scaleNode` | Defines the scale. | `vec2` |
+
+## Transitioning common GLSL properties to TSL
+
+| GLSL | TSL | Type |
+| -- | -- | -- |
+| `position` | `positionGeometry` | `vec3` |
+| `transformed` | `positionLocal` | `vec3` |
+| `transformedNormal` | `normalLocal` | `vec3` |
+| `vWorldPosition` | `positionWorld` | `vec3` |
+| `vColor` | `vertexColor()` | `vec3` |
+| `vUv` \| `uv` | `uv()` | `vec2` |
+| `vNormal` | `normalView` | `vec3` |
+| `viewMatrix` | `cameraViewMatrix` | `mat4` |
+| `modelMatrix` | `modelWorldMatrix` | `mat4` |
+| `modelViewMatrix` | `modelViewMatrix` | `mat4` |
+| `projectionMatrix` | `cameraProjectionMatrix` | `mat4` |
+| `diffuseColor` | `material.colorNode` | `vec4` |
+| `gl_FragColor` | `material.fragmentNode` | `vec4` |
+
+
+
+---
+
+## Available Documentation
+
+The following documentation pages are available in markdown format at `https://threejs.org/docs/pages/{Name}.html.md`:
+
+### Core
+
+- [ARButton](https://threejs.org/docs/pages/ARButton.html.md)
+- [AmmoPhysics](https://threejs.org/docs/pages/AmmoPhysics.html.md)
+- [BasicLightingModel](https://threejs.org/docs/pages/BasicLightingModel.html.md)
+- [BatchedMesh](https://threejs.org/docs/pages/BatchedMesh.html.md)
+- [BitonicSort_BitonicSort](https://threejs.org/docs/pages/BitonicSort_BitonicSort.html.md)
+- [Bone](https://threejs.org/docs/pages/Bone.html.md)
+- [BooleanKeyframeTrack](https://threejs.org/docs/pages/BooleanKeyframeTrack.html.md)
+- [BufferAttribute](https://threejs.org/docs/pages/BufferAttribute.html.md)
+- [BundleGroup](https://threejs.org/docs/pages/BundleGroup.html.md)
+- [CCDIKSolver](https://threejs.org/docs/pages/CCDIKSolver.html.md)
+- [CSM](https://threejs.org/docs/pages/CSM.html.md)
+- [CSMFrustum](https://threejs.org/docs/pages/CSMFrustum.html.md)
+- [CSS2DObject](https://threejs.org/docs/pages/CSS2DObject.html.md)
+- [CSS2DRenderer](https://threejs.org/docs/pages/CSS2DRenderer.html.md)
+- [CSS3DObject](https://threejs.org/docs/pages/CSS3DObject.html.md)
+- [CSS3DRenderer](https://threejs.org/docs/pages/CSS3DRenderer.html.md)
+- [CSS3DSprite](https://threejs.org/docs/pages/CSS3DSprite.html.md)
+- [Cache](https://threejs.org/docs/pages/Cache.html.md)
+- [CanvasTarget](https://threejs.org/docs/pages/CanvasTarget.html.md)
+- [Capsule](https://threejs.org/docs/pages/Capsule.html.md)
+- [CinquefoilKnot](https://threejs.org/docs/pages/CinquefoilKnot.html.md)
+- [ClippingGroup](https://threejs.org/docs/pages/ClippingGroup.html.md)
+- [Clock](https://threejs.org/docs/pages/Clock.html.md)
+- [ColorConverter](https://threejs.org/docs/pages/ColorConverter.html.md)
+- [ColorKeyframeTrack](https://threejs.org/docs/pages/ColorKeyframeTrack.html.md)
+- [ConvexHull](https://threejs.org/docs/pages/ConvexHull.html.md)
+- [ConvexObjectBreaker](https://threejs.org/docs/pages/ConvexObjectBreaker.html.md)
+- [CubeRenderTarget](https://threejs.org/docs/pages/CubeRenderTarget.html.md)
+- [CubicInterpolant](https://threejs.org/docs/pages/CubicInterpolant.html.md)
+- [Cylindrical](https://threejs.org/docs/pages/Cylindrical.html.md)
+- [DRACOExporter](https://threejs.org/docs/pages/DRACOExporter.html.md)
+- [DataUtils](https://threejs.org/docs/pages/DataUtils.html.md)
+- [DebugEnvironment](https://threejs.org/docs/pages/DebugEnvironment.html.md)
+- [DecoratedTorusKnot4a](https://threejs.org/docs/pages/DecoratedTorusKnot4a.html.md)
+- [DecoratedTorusKnot4b](https://threejs.org/docs/pages/DecoratedTorusKnot4b.html.md)
+- [DecoratedTorusKnot5a](https://threejs.org/docs/pages/DecoratedTorusKnot5a.html.md)
+- [DecoratedTorusKnot5c](https://threejs.org/docs/pages/DecoratedTorusKnot5c.html.md)
+- [DirectionalLightShadow](https://threejs.org/docs/pages/DirectionalLightShadow.html.md)
+- [DiscreteInterpolant](https://threejs.org/docs/pages/DiscreteInterpolant.html.md)
+- [Earcut](https://threejs.org/docs/pages/Earcut.html.md)
+- [EdgeSplitModifier](https://threejs.org/docs/pages/EdgeSplitModifier.html.md)
+- [EffectComposer](https://threejs.org/docs/pages/EffectComposer.html.md)
+- [EventDispatcher](https://threejs.org/docs/pages/EventDispatcher.html.md)
+- [FigureEightPolynomialKnot](https://threejs.org/docs/pages/FigureEightPolynomialKnot.html.md)
+- [Float16BufferAttribute](https://threejs.org/docs/pages/Float16BufferAttribute.html.md)
+- [Float32BufferAttribute](https://threejs.org/docs/pages/Float32BufferAttribute.html.md)
+- [Flow](https://threejs.org/docs/pages/Flow.html.md)
+- [Fog](https://threejs.org/docs/pages/Fog.html.md)
+- [FogExp2](https://threejs.org/docs/pages/FogExp2.html.md)
+- [Font](https://threejs.org/docs/pages/Font.html.md)
+- [FullScreenQuad](https://threejs.org/docs/pages/FullScreenQuad.html.md)
+- [GLBufferAttribute](https://threejs.org/docs/pages/GLBufferAttribute.html.md)
+- [GLSLNodeBuilder](https://threejs.org/docs/pages/GLSLNodeBuilder.html.md)
+- [GLSLNodeFunction](https://threejs.org/docs/pages/GLSLNodeFunction.html.md)
+- [GLSLNodeParser](https://threejs.org/docs/pages/GLSLNodeParser.html.md)
+- [GLTFExporter](https://threejs.org/docs/pages/GLTFExporter.html.md)
+- [GPUComputationRenderer](https://threejs.org/docs/pages/GPUComputationRenderer.html.md)
+- [GrannyKnot](https://threejs.org/docs/pages/GrannyKnot.html.md)
+- [GroundedSkybox](https://threejs.org/docs/pages/GroundedSkybox.html.md)
+- [Group](https://threejs.org/docs/pages/Group.html.md)
+- [Gyroscope](https://threejs.org/docs/pages/Gyroscope.html.md)
+- [HTMLMesh](https://threejs.org/docs/pages/HTMLMesh.html.md)
+- [ImageUtils](https://threejs.org/docs/pages/ImageUtils.html.md)
+- [ImprovedNoise](https://threejs.org/docs/pages/ImprovedNoise.html.md)
+- [IndirectStorageBufferAttribute](https://threejs.org/docs/pages/IndirectStorageBufferAttribute.html.md)
+- [Info](https://threejs.org/docs/pages/Info.html.md)
+- [InspectorBase](https://threejs.org/docs/pages/InspectorBase.html.md)
+- [InstancedBufferAttribute](https://threejs.org/docs/pages/InstancedBufferAttribute.html.md)
+- [InstancedFlow](https://threejs.org/docs/pages/InstancedFlow.html.md)
+- [InstancedInterleavedBuffer](https://threejs.org/docs/pages/InstancedInterleavedBuffer.html.md)
+- [InstancedMesh](https://threejs.org/docs/pages/InstancedMesh.html.md)
+- [Int16BufferAttribute](https://threejs.org/docs/pages/Int16BufferAttribute.html.md)
+- [Int32BufferAttribute](https://threejs.org/docs/pages/Int32BufferAttribute.html.md)
+- [Int8BufferAttribute](https://threejs.org/docs/pages/Int8BufferAttribute.html.md)
+- [InteractiveGroup](https://threejs.org/docs/pages/InteractiveGroup.html.md)
+- [InterleavedBuffer](https://threejs.org/docs/pages/InterleavedBuffer.html.md)
+- [InterleavedBufferAttribute](https://threejs.org/docs/pages/InterleavedBufferAttribute.html.md)
+- [Interpolant](https://threejs.org/docs/pages/Interpolant.html.md)
+- [JoltPhysics](https://threejs.org/docs/pages/JoltPhysics.html.md)
+- [KTX2Exporter](https://threejs.org/docs/pages/KTX2Exporter.html.md)
+- [KeyframeTrack](https://threejs.org/docs/pages/KeyframeTrack.html.md)
+- [LDrawUtils](https://threejs.org/docs/pages/LDrawUtils.html.md)
+- [LOD](https://threejs.org/docs/pages/LOD.html.md)
+- [Layers](https://threejs.org/docs/pages/Layers.html.md)
+- [Lensflare](https://threejs.org/docs/pages/Lensflare.html.md)
+- [LensflareElement](https://threejs.org/docs/pages/LensflareElement.html.md)
+- [LensflareMesh](https://threejs.org/docs/pages/LensflareMesh.html.md)
+- [LightProbe](https://threejs.org/docs/pages/LightProbe.html.md)
+- [LightProbeGenerator](https://threejs.org/docs/pages/LightProbeGenerator.html.md)
+- [LightShadow](https://threejs.org/docs/pages/LightShadow.html.md)
+- [LightingModel](https://threejs.org/docs/pages/LightingModel.html.md)
+- [Line](https://threejs.org/docs/pages/Line.html.md)
+- [Line2](https://threejs.org/docs/pages/Line2.html.md)
+- [Line3](https://threejs.org/docs/pages/Line3.html.md)
+- [LineLoop](https://threejs.org/docs/pages/LineLoop.html.md)
+- [LineSegments](https://threejs.org/docs/pages/LineSegments.html.md)
+- [LineSegments2](https://threejs.org/docs/pages/LineSegments2.html.md)
+- [LinearInterpolant](https://threejs.org/docs/pages/LinearInterpolant.html.md)
+- [LoaderUtils](https://threejs.org/docs/pages/LoaderUtils.html.md)
+- [LoadingManager](https://threejs.org/docs/pages/LoadingManager.html.md)
+- [Lut](https://threejs.org/docs/pages/Lut.html.md)
+- [MD2Character](https://threejs.org/docs/pages/MD2Character.html.md)
+- [MD2CharacterComplex](https://threejs.org/docs/pages/MD2CharacterComplex.html.md)
+- [MarchingCubes](https://threejs.org/docs/pages/MarchingCubes.html.md)
+- [MathUtils](https://threejs.org/docs/pages/MathUtils.html.md)
+- [Mesh](https://threejs.org/docs/pages/Mesh.html.md)
+- [MeshSurfaceSampler](https://threejs.org/docs/pages/MeshSurfaceSampler.html.md)
+- [MorphAnimMesh](https://threejs.org/docs/pages/MorphAnimMesh.html.md)
+- [MorphBlendMesh](https://threejs.org/docs/pages/MorphBlendMesh.html.md)
+- [NURBSSurface](https://threejs.org/docs/pages/NURBSSurface.html.md)
+- [NURBSVolume](https://threejs.org/docs/pages/NURBSVolume.html.md)
+- [NodeAttribute](https://threejs.org/docs/pages/NodeAttribute.html.md)
+- [NodeBuilder](https://threejs.org/docs/pages/NodeBuilder.html.md)
+- [NodeCache](https://threejs.org/docs/pages/NodeCache.html.md)
+- [NodeCode](https://threejs.org/docs/pages/NodeCode.html.md)
+- [NodeFrame](https://threejs.org/docs/pages/NodeFrame.html.md)
+- [NodeFunction](https://threejs.org/docs/pages/NodeFunction.html.md)
+- [NodeFunctionInput](https://threejs.org/docs/pages/NodeFunctionInput.html.md)
+- [NodeMaterialObserver](https://threejs.org/docs/pages/NodeMaterialObserver.html.md)
+- [NodeParser](https://threejs.org/docs/pages/NodeParser.html.md)
+- [NodeUniform](https://threejs.org/docs/pages/NodeUniform.html.md)
+- [NodeVar](https://threejs.org/docs/pages/NodeVar.html.md)
+- [NodeVarying](https://threejs.org/docs/pages/NodeVarying.html.md)
+- [NumberKeyframeTrack](https://threejs.org/docs/pages/NumberKeyframeTrack.html.md)
+- [OBB](https://threejs.org/docs/pages/OBB.html.md)
+- [OBJExporter](https://threejs.org/docs/pages/OBJExporter.html.md)
+- [Object3D](https://threejs.org/docs/pages/Object3D.html.md)
+- [Octree](https://threejs.org/docs/pages/Octree.html.md)
+- [OculusHandModel](https://threejs.org/docs/pages/OculusHandModel.html.md)
+- [OculusHandPointerModel](https://threejs.org/docs/pages/OculusHandPointerModel.html.md)
+- [PLYExporter](https://threejs.org/docs/pages/PLYExporter.html.md)
+- [PMREMGenerator](https://threejs.org/docs/pages/PMREMGenerator.html.md)
+- [Path](https://threejs.org/docs/pages/Path.html.md)
+- [PhongLightingModel](https://threejs.org/docs/pages/PhongLightingModel.html.md)
+- [PhysicalLightingModel](https://threejs.org/docs/pages/PhysicalLightingModel.html.md)
+- [PointLightShadow](https://threejs.org/docs/pages/PointLightShadow.html.md)
+- [Points](https://threejs.org/docs/pages/Points.html.md)
+- [PostProcessing](https://threejs.org/docs/pages/PostProcessing.html.md)
+- [ProgressiveLightMap](https://threejs.org/docs/pages/ProgressiveLightMap.html.md)
+- [Projector](https://threejs.org/docs/pages/Projector.html.md)
+- [PropertyBinding](https://threejs.org/docs/pages/PropertyBinding.html.md)
+- [PropertyMixer](https://threejs.org/docs/pages/PropertyMixer.html.md)
+- [QuadMesh](https://threejs.org/docs/pages/QuadMesh.html.md)
+- [RapierPhysics](https://threejs.org/docs/pages/RapierPhysics.html.md)
+- [RectAreaLightTexturesLib](https://threejs.org/docs/pages/RectAreaLightTexturesLib.html.md)
+- [RectAreaLightUniformsLib](https://threejs.org/docs/pages/RectAreaLightUniformsLib.html.md)
+- [Reflector](https://threejs.org/docs/pages/Reflector.html.md)
+- [Refractor](https://threejs.org/docs/pages/Refractor.html.md)
+- [RenderTarget](https://threejs.org/docs/pages/RenderTarget.html.md)
+- [RenderTarget3D](https://threejs.org/docs/pages/RenderTarget3D.html.md)
+- [Renderer](https://threejs.org/docs/pages/Renderer.html.md)
+- [Resources](https://threejs.org/docs/pages/Resources.html.md)
+- [RoomEnvironment](https://threejs.org/docs/pages/RoomEnvironment.html.md)
+- [SSSLightingModel](https://threejs.org/docs/pages/SSSLightingModel.html.md)
+- [STLExporter](https://threejs.org/docs/pages/STLExporter.html.md)
+- [SVGObject](https://threejs.org/docs/pages/SVGObject.html.md)
+- [SVGRenderer](https://threejs.org/docs/pages/SVGRenderer.html.md)
+- [Scene](https://threejs.org/docs/pages/Scene.html.md)
+- [SceneOptimizer](https://threejs.org/docs/pages/SceneOptimizer.html.md)
+- [SelectionBox](https://threejs.org/docs/pages/SelectionBox.html.md)
+- [ShadowMapViewer](https://threejs.org/docs/pages/ShadowMapViewer.html.md)
+- [ShadowMaskModel](https://threejs.org/docs/pages/ShadowMaskModel.html.md)
+- [ShadowMesh](https://threejs.org/docs/pages/ShadowMesh.html.md)
+- [Shape](https://threejs.org/docs/pages/Shape.html.md)
+- [ShapePath](https://threejs.org/docs/pages/ShapePath.html.md)
+- [ShapeUtils](https://threejs.org/docs/pages/ShapeUtils.html.md)
+- [SimplexNoise](https://threejs.org/docs/pages/SimplexNoise.html.md)
+- [SimplifyModifier](https://threejs.org/docs/pages/SimplifyModifier.html.md)
+- [Skeleton](https://threejs.org/docs/pages/Skeleton.html.md)
+- [SkinnedMesh](https://threejs.org/docs/pages/SkinnedMesh.html.md)
+- [Sky](https://threejs.org/docs/pages/Sky.html.md)
+- [SkyMesh](https://threejs.org/docs/pages/SkyMesh.html.md)
+- [Source](https://threejs.org/docs/pages/Source.html.md)
+- [Spherical](https://threejs.org/docs/pages/Spherical.html.md)
+- [SphericalHarmonics3](https://threejs.org/docs/pages/SphericalHarmonics3.html.md)
+- [SpotLightShadow](https://threejs.org/docs/pages/SpotLightShadow.html.md)
+- [Sprite](https://threejs.org/docs/pages/Sprite.html.md)
+- [StorageBufferAttribute](https://threejs.org/docs/pages/StorageBufferAttribute.html.md)
+- [StorageInstancedBufferAttribute](https://threejs.org/docs/pages/StorageInstancedBufferAttribute.html.md)
+- [StringKeyframeTrack](https://threejs.org/docs/pages/StringKeyframeTrack.html.md)
+- [TSL](https://threejs.org/docs/pages/TSL.html.md)
+- [Tab](https://threejs.org/docs/pages/Tab.html.md)
+- [TessellateModifier](https://threejs.org/docs/pages/TessellateModifier.html.md)
+- [TextureUtils](https://threejs.org/docs/pages/TextureUtils.html.md)
+- [TiledLighting](https://threejs.org/docs/pages/TiledLighting.html.md)
+- [Timer](https://threejs.org/docs/pages/Timer.html.md)
+- [TimestampQueryPool](https://threejs.org/docs/pages/TimestampQueryPool.html.md)
+- [ToonLightingModel](https://threejs.org/docs/pages/ToonLightingModel.html.md)
+- [TorusKnot](https://threejs.org/docs/pages/TorusKnot.html.md)
+- [Transpiler](https://threejs.org/docs/pages/Transpiler.html.md)
+- [TrefoilKnot](https://threejs.org/docs/pages/TrefoilKnot.html.md)
+- [TrefoilPolynomialKnot](https://threejs.org/docs/pages/TrefoilPolynomialKnot.html.md)
+- [TubePainter](https://threejs.org/docs/pages/TubePainter.html.md)
+- [USDZExporter](https://threejs.org/docs/pages/USDZExporter.html.md)
+- [Uint16BufferAttribute](https://threejs.org/docs/pages/Uint16BufferAttribute.html.md)
+- [Uint32BufferAttribute](https://threejs.org/docs/pages/Uint32BufferAttribute.html.md)
+- [Uint8BufferAttribute](https://threejs.org/docs/pages/Uint8BufferAttribute.html.md)
+- [Uint8ClampedBufferAttribute](https://threejs.org/docs/pages/Uint8ClampedBufferAttribute.html.md)
+- [Uniform](https://threejs.org/docs/pages/Uniform.html.md)
+- [UniformsGroup](https://threejs.org/docs/pages/UniformsGroup.html.md)
+- [VOXMesh](https://threejs.org/docs/pages/VOXMesh.html.md)
+- [VRButton](https://threejs.org/docs/pages/VRButton.html.md)
+- [Volume](https://threejs.org/docs/pages/Volume.html.md)
+- [VolumeSlice](https://threejs.org/docs/pages/VolumeSlice.html.md)
+- [VolumetricLightingModel](https://threejs.org/docs/pages/VolumetricLightingModel.html.md)
+- [WGSLNodeBuilder](https://threejs.org/docs/pages/WGSLNodeBuilder.html.md)
+- [WGSLNodeFunction](https://threejs.org/docs/pages/WGSLNodeFunction.html.md)
+- [WGSLNodeParser](https://threejs.org/docs/pages/WGSLNodeParser.html.md)
+- [Water](https://threejs.org/docs/pages/Water.html.md)
+- [WaterMesh](https://threejs.org/docs/pages/WaterMesh.html.md)
+- [WebGL](https://threejs.org/docs/pages/WebGL.html.md)
+- [WebGL3DRenderTarget](https://threejs.org/docs/pages/WebGL3DRenderTarget.html.md)
+- [WebGLArrayRenderTarget](https://threejs.org/docs/pages/WebGLArrayRenderTarget.html.md)
+- [WebGLCubeRenderTarget](https://threejs.org/docs/pages/WebGLCubeRenderTarget.html.md)
+- [WebGLRenderTarget](https://threejs.org/docs/pages/WebGLRenderTarget.html.md)
+- [WebGLRenderer](https://threejs.org/docs/pages/WebGLRenderer.html.md)
+- [WebGLTimestampQueryPool](https://threejs.org/docs/pages/WebGLTimestampQueryPool.html.md)
+- [WebGPU](https://threejs.org/docs/pages/WebGPU.html.md)
+- [WebGPURenderer](https://threejs.org/docs/pages/WebGPURenderer.html.md)
+- [WebGPUTimestampQueryPool](https://threejs.org/docs/pages/WebGPUTimestampQueryPool.html.md)
+- [Wireframe](https://threejs.org/docs/pages/Wireframe.html.md)
+- [WireframeGeometry2](https://threejs.org/docs/pages/WireframeGeometry2.html.md)
+- [WorkerPool](https://threejs.org/docs/pages/WorkerPool.html.md)
+
+### Cameras
+
+- [ArrayCamera](https://threejs.org/docs/pages/ArrayCamera.html.md)
+- [Camera](https://threejs.org/docs/pages/Camera.html.md)
+- [CubeCamera](https://threejs.org/docs/pages/CubeCamera.html.md)
+- [OrthographicCamera](https://threejs.org/docs/pages/OrthographicCamera.html.md)
+- [PerspectiveCamera](https://threejs.org/docs/pages/PerspectiveCamera.html.md)
+- [StereoCamera](https://threejs.org/docs/pages/StereoCamera.html.md)
+
+### Lights
+
+- [AmbientLight](https://threejs.org/docs/pages/AmbientLight.html.md)
+- [DirectionalLight](https://threejs.org/docs/pages/DirectionalLight.html.md)
+- [HemisphereLight](https://threejs.org/docs/pages/HemisphereLight.html.md)
+- [IESSpotLight](https://threejs.org/docs/pages/IESSpotLight.html.md)
+- [Light](https://threejs.org/docs/pages/Light.html.md)
+- [PointLight](https://threejs.org/docs/pages/PointLight.html.md)
+- [ProjectorLight](https://threejs.org/docs/pages/ProjectorLight.html.md)
+- [RectAreaLight](https://threejs.org/docs/pages/RectAreaLight.html.md)
+- [SpotLight](https://threejs.org/docs/pages/SpotLight.html.md)
+- [XREstimatedLight](https://threejs.org/docs/pages/XREstimatedLight.html.md)
+
+### Materials
+
+- [LDrawConditionalLineMaterial](https://threejs.org/docs/pages/LDrawConditionalLineMaterial.html.md)
+- [Line2NodeMaterial](https://threejs.org/docs/pages/Line2NodeMaterial.html.md)
+- [LineBasicMaterial](https://threejs.org/docs/pages/LineBasicMaterial.html.md)
+- [LineBasicNodeMaterial](https://threejs.org/docs/pages/LineBasicNodeMaterial.html.md)
+- [LineDashedMaterial](https://threejs.org/docs/pages/LineDashedMaterial.html.md)
+- [LineDashedNodeMaterial](https://threejs.org/docs/pages/LineDashedNodeMaterial.html.md)
+- [LineMaterial](https://threejs.org/docs/pages/LineMaterial.html.md)
+- [Material](https://threejs.org/docs/pages/Material.html.md)
+- [MeshBasicMaterial](https://threejs.org/docs/pages/MeshBasicMaterial.html.md)
+- [MeshBasicNodeMaterial](https://threejs.org/docs/pages/MeshBasicNodeMaterial.html.md)
+- [MeshDepthMaterial](https://threejs.org/docs/pages/MeshDepthMaterial.html.md)
+- [MeshDistanceMaterial](https://threejs.org/docs/pages/MeshDistanceMaterial.html.md)
+- [MeshLambertMaterial](https://threejs.org/docs/pages/MeshLambertMaterial.html.md)
+- [MeshLambertNodeMaterial](https://threejs.org/docs/pages/MeshLambertNodeMaterial.html.md)
+- [MeshMatcapMaterial](https://threejs.org/docs/pages/MeshMatcapMaterial.html.md)
+- [MeshMatcapNodeMaterial](https://threejs.org/docs/pages/MeshMatcapNodeMaterial.html.md)
+- [MeshNormalMaterial](https://threejs.org/docs/pages/MeshNormalMaterial.html.md)
+- [MeshNormalNodeMaterial](https://threejs.org/docs/pages/MeshNormalNodeMaterial.html.md)
+- [MeshPhongMaterial](https://threejs.org/docs/pages/MeshPhongMaterial.html.md)
+- [MeshPhongNodeMaterial](https://threejs.org/docs/pages/MeshPhongNodeMaterial.html.md)
+- [MeshPhysicalMaterial](https://threejs.org/docs/pages/MeshPhysicalMaterial.html.md)
+- [MeshPhysicalNodeMaterial](https://threejs.org/docs/pages/MeshPhysicalNodeMaterial.html.md)
+- [MeshPostProcessingMaterial](https://threejs.org/docs/pages/MeshPostProcessingMaterial.html.md)
+- [MeshSSSNodeMaterial](https://threejs.org/docs/pages/MeshSSSNodeMaterial.html.md)
+- [MeshStandardMaterial](https://threejs.org/docs/pages/MeshStandardMaterial.html.md)
+- [MeshStandardNodeMaterial](https://threejs.org/docs/pages/MeshStandardNodeMaterial.html.md)
+- [MeshToonMaterial](https://threejs.org/docs/pages/MeshToonMaterial.html.md)
+- [MeshToonNodeMaterial](https://threejs.org/docs/pages/MeshToonNodeMaterial.html.md)
+- [NodeMaterial](https://threejs.org/docs/pages/NodeMaterial.html.md)
+- [PointsMaterial](https://threejs.org/docs/pages/PointsMaterial.html.md)
+- [PointsNodeMaterial](https://threejs.org/docs/pages/PointsNodeMaterial.html.md)
+- [RawShaderMaterial](https://threejs.org/docs/pages/RawShaderMaterial.html.md)
+- [ShaderMaterial](https://threejs.org/docs/pages/ShaderMaterial.html.md)
+- [ShadowMaterial](https://threejs.org/docs/pages/ShadowMaterial.html.md)
+- [ShadowNodeMaterial](https://threejs.org/docs/pages/ShadowNodeMaterial.html.md)
+- [SpriteMaterial](https://threejs.org/docs/pages/SpriteMaterial.html.md)
+- [SpriteNodeMaterial](https://threejs.org/docs/pages/SpriteNodeMaterial.html.md)
+- [VolumeNodeMaterial](https://threejs.org/docs/pages/VolumeNodeMaterial.html.md)
+- [WoodNodeMaterial](https://threejs.org/docs/pages/WoodNodeMaterial.html.md)
+
+### Geometries
+
+- [BoxGeometry](https://threejs.org/docs/pages/BoxGeometry.html.md)
+- [BoxLineGeometry](https://threejs.org/docs/pages/BoxLineGeometry.html.md)
+- [BufferGeometry](https://threejs.org/docs/pages/BufferGeometry.html.md)
+- [CapsuleGeometry](https://threejs.org/docs/pages/CapsuleGeometry.html.md)
+- [CircleGeometry](https://threejs.org/docs/pages/CircleGeometry.html.md)
+- [ConeGeometry](https://threejs.org/docs/pages/ConeGeometry.html.md)
+- [ConvexGeometry](https://threejs.org/docs/pages/ConvexGeometry.html.md)
+- [CylinderGeometry](https://threejs.org/docs/pages/CylinderGeometry.html.md)
+- [DecalGeometry](https://threejs.org/docs/pages/DecalGeometry.html.md)
+- [DodecahedronGeometry](https://threejs.org/docs/pages/DodecahedronGeometry.html.md)
+- [EdgesGeometry](https://threejs.org/docs/pages/EdgesGeometry.html.md)
+- [ExtrudeGeometry](https://threejs.org/docs/pages/ExtrudeGeometry.html.md)
+- [IcosahedronGeometry](https://threejs.org/docs/pages/IcosahedronGeometry.html.md)
+- [InstancedBufferGeometry](https://threejs.org/docs/pages/InstancedBufferGeometry.html.md)
+- [LatheGeometry](https://threejs.org/docs/pages/LatheGeometry.html.md)
+- [LineGeometry](https://threejs.org/docs/pages/LineGeometry.html.md)
+- [LineSegmentsGeometry](https://threejs.org/docs/pages/LineSegmentsGeometry.html.md)
+- [OctahedronGeometry](https://threejs.org/docs/pages/OctahedronGeometry.html.md)
+- [ParametricGeometry](https://threejs.org/docs/pages/ParametricGeometry.html.md)
+- [PlaneGeometry](https://threejs.org/docs/pages/PlaneGeometry.html.md)
+- [PolyhedronGeometry](https://threejs.org/docs/pages/PolyhedronGeometry.html.md)
+- [RingGeometry](https://threejs.org/docs/pages/RingGeometry.html.md)
+- [RollerCoasterGeometry](https://threejs.org/docs/pages/RollerCoasterGeometry.html.md)
+- [RollerCoasterLiftersGeometry](https://threejs.org/docs/pages/RollerCoasterLiftersGeometry.html.md)
+- [RollerCoasterShadowGeometry](https://threejs.org/docs/pages/RollerCoasterShadowGeometry.html.md)
+- [RoundedBoxGeometry](https://threejs.org/docs/pages/RoundedBoxGeometry.html.md)
+- [ShapeGeometry](https://threejs.org/docs/pages/ShapeGeometry.html.md)
+- [SkyGeometry](https://threejs.org/docs/pages/SkyGeometry.html.md)
+- [SphereGeometry](https://threejs.org/docs/pages/SphereGeometry.html.md)
+- [TeapotGeometry](https://threejs.org/docs/pages/TeapotGeometry.html.md)
+- [TetrahedronGeometry](https://threejs.org/docs/pages/TetrahedronGeometry.html.md)
+- [TextGeometry](https://threejs.org/docs/pages/TextGeometry.html.md)
+- [TorusGeometry](https://threejs.org/docs/pages/TorusGeometry.html.md)
+- [TorusKnotGeometry](https://threejs.org/docs/pages/TorusKnotGeometry.html.md)
+- [TreesGeometry](https://threejs.org/docs/pages/TreesGeometry.html.md)
+- [TubeGeometry](https://threejs.org/docs/pages/TubeGeometry.html.md)
+- [WireframeGeometry](https://threejs.org/docs/pages/WireframeGeometry.html.md)
+
+### Textures
+
+- [CanvasTexture](https://threejs.org/docs/pages/CanvasTexture.html.md)
+- [CompressedArrayTexture](https://threejs.org/docs/pages/CompressedArrayTexture.html.md)
+- [CompressedCubeTexture](https://threejs.org/docs/pages/CompressedCubeTexture.html.md)
+- [CompressedTexture](https://threejs.org/docs/pages/CompressedTexture.html.md)
+- [CubeDepthTexture](https://threejs.org/docs/pages/CubeDepthTexture.html.md)
+- [CubeTexture](https://threejs.org/docs/pages/CubeTexture.html.md)
+- [Data3DTexture](https://threejs.org/docs/pages/Data3DTexture.html.md)
+- [DataArrayTexture](https://threejs.org/docs/pages/DataArrayTexture.html.md)
+- [DataTexture](https://threejs.org/docs/pages/DataTexture.html.md)
+- [DepthTexture](https://threejs.org/docs/pages/DepthTexture.html.md)
+- [ExternalTexture](https://threejs.org/docs/pages/ExternalTexture.html.md)
+- [FlakesTexture](https://threejs.org/docs/pages/FlakesTexture.html.md)
+- [FramebufferTexture](https://threejs.org/docs/pages/FramebufferTexture.html.md)
+- [Storage3DTexture](https://threejs.org/docs/pages/Storage3DTexture.html.md)
+- [StorageArrayTexture](https://threejs.org/docs/pages/StorageArrayTexture.html.md)
+- [StorageTexture](https://threejs.org/docs/pages/StorageTexture.html.md)
+- [Texture](https://threejs.org/docs/pages/Texture.html.md)
+- [VOXData3DTexture](https://threejs.org/docs/pages/VOXData3DTexture.html.md)
+- [VideoFrameTexture](https://threejs.org/docs/pages/VideoFrameTexture.html.md)
+- [VideoTexture](https://threejs.org/docs/pages/VideoTexture.html.md)
+
+### Loaders
+
+- [AMFLoader](https://threejs.org/docs/pages/AMFLoader.html.md)
+- [AnimationLoader](https://threejs.org/docs/pages/AnimationLoader.html.md)
+- [AudioLoader](https://threejs.org/docs/pages/AudioLoader.html.md)
+- [BVHLoader](https://threejs.org/docs/pages/BVHLoader.html.md)
+- [BufferGeometryLoader](https://threejs.org/docs/pages/BufferGeometryLoader.html.md)
+- [ColladaLoader](https://threejs.org/docs/pages/ColladaLoader.html.md)
+- [CompressedTextureLoader](https://threejs.org/docs/pages/CompressedTextureLoader.html.md)
+- [CubeTextureLoader](https://threejs.org/docs/pages/CubeTextureLoader.html.md)
+- [DDSLoader](https://threejs.org/docs/pages/DDSLoader.html.md)
+- [DRACOLoader](https://threejs.org/docs/pages/DRACOLoader.html.md)
+- [DataTextureLoader](https://threejs.org/docs/pages/DataTextureLoader.html.md)
+- [EXRLoader](https://threejs.org/docs/pages/EXRLoader.html.md)
+- [FBXLoader](https://threejs.org/docs/pages/FBXLoader.html.md)
+- [FileLoader](https://threejs.org/docs/pages/FileLoader.html.md)
+- [FontLoader](https://threejs.org/docs/pages/FontLoader.html.md)
+- [GCodeLoader](https://threejs.org/docs/pages/GCodeLoader.html.md)
+- [GLTFLoader](https://threejs.org/docs/pages/GLTFLoader.html.md)
+- [HDRCubeTextureLoader](https://threejs.org/docs/pages/HDRCubeTextureLoader.html.md)
+- [HDRLoader](https://threejs.org/docs/pages/HDRLoader.html.md)
+- [IESLoader](https://threejs.org/docs/pages/IESLoader.html.md)
+- [ImageBitmapLoader](https://threejs.org/docs/pages/ImageBitmapLoader.html.md)
+- [ImageLoader](https://threejs.org/docs/pages/ImageLoader.html.md)
+- [KMZLoader](https://threejs.org/docs/pages/KMZLoader.html.md)
+- [KTX2Loader](https://threejs.org/docs/pages/KTX2Loader.html.md)
+- [KTXLoader](https://threejs.org/docs/pages/KTXLoader.html.md)
+- [LDrawLoader](https://threejs.org/docs/pages/LDrawLoader.html.md)
+- [LUT3dlLoader](https://threejs.org/docs/pages/LUT3dlLoader.html.md)
+- [LUTCubeLoader](https://threejs.org/docs/pages/LUTCubeLoader.html.md)
+- [LUTImageLoader](https://threejs.org/docs/pages/LUTImageLoader.html.md)
+- [LWOLoader](https://threejs.org/docs/pages/LWOLoader.html.md)
+- [Loader](https://threejs.org/docs/pages/Loader.html.md)
+- [LottieLoader](https://threejs.org/docs/pages/LottieLoader.html.md)
+- [MD2Loader](https://threejs.org/docs/pages/MD2Loader.html.md)
+- [MDDLoader](https://threejs.org/docs/pages/MDDLoader.html.md)
+- [MTLLoader](https://threejs.org/docs/pages/MTLLoader.html.md)
+- [MaterialLoader](https://threejs.org/docs/pages/MaterialLoader.html.md)
+- [MaterialXLoader](https://threejs.org/docs/pages/MaterialXLoader.html.md)
+- [NRRDLoader](https://threejs.org/docs/pages/NRRDLoader.html.md)
+- [NodeLoader](https://threejs.org/docs/pages/NodeLoader.html.md)
+- [NodeMaterialLoader](https://threejs.org/docs/pages/NodeMaterialLoader.html.md)
+- [NodeObjectLoader](https://threejs.org/docs/pages/NodeObjectLoader.html.md)
+- [OBJLoader](https://threejs.org/docs/pages/OBJLoader.html.md)
+- [ObjectLoader](https://threejs.org/docs/pages/ObjectLoader.html.md)
+- [PCDLoader](https://threejs.org/docs/pages/PCDLoader.html.md)
+- [PDBLoader](https://threejs.org/docs/pages/PDBLoader.html.md)
+- [PLYLoader](https://threejs.org/docs/pages/PLYLoader.html.md)
+- [PVRLoader](https://threejs.org/docs/pages/PVRLoader.html.md)
+- [Rhino3dmLoader](https://threejs.org/docs/pages/Rhino3dmLoader.html.md)
+- [STLLoader](https://threejs.org/docs/pages/STLLoader.html.md)
+- [SVGLoader](https://threejs.org/docs/pages/SVGLoader.html.md)
+- [TDSLoader](https://threejs.org/docs/pages/TDSLoader.html.md)
+- [TGALoader](https://threejs.org/docs/pages/TGALoader.html.md)
+- [TIFFLoader](https://threejs.org/docs/pages/TIFFLoader.html.md)
+- [TTFLoader](https://threejs.org/docs/pages/TTFLoader.html.md)
+- [TextureLoader](https://threejs.org/docs/pages/TextureLoader.html.md)
+- [ThreeMFLoader](https://threejs.org/docs/pages/ThreeMFLoader.html.md)
+- [USDLoader](https://threejs.org/docs/pages/USDLoader.html.md)
+- [UltraHDRLoader](https://threejs.org/docs/pages/UltraHDRLoader.html.md)
+- [VOXLoader](https://threejs.org/docs/pages/VOXLoader.html.md)
+- [VRMLLoader](https://threejs.org/docs/pages/VRMLLoader.html.md)
+- [VTKLoader](https://threejs.org/docs/pages/VTKLoader.html.md)
+- [XYZLoader](https://threejs.org/docs/pages/XYZLoader.html.md)
+
+### Controls
+
+- [ArcballControls](https://threejs.org/docs/pages/ArcballControls.html.md)
+- [Controls](https://threejs.org/docs/pages/Controls.html.md)
+- [DragControls](https://threejs.org/docs/pages/DragControls.html.md)
+- [FirstPersonControls](https://threejs.org/docs/pages/FirstPersonControls.html.md)
+- [FlyControls](https://threejs.org/docs/pages/FlyControls.html.md)
+- [MapControls](https://threejs.org/docs/pages/MapControls.html.md)
+- [OrbitControls](https://threejs.org/docs/pages/OrbitControls.html.md)
+- [PointerLockControls](https://threejs.org/docs/pages/PointerLockControls.html.md)
+- [TrackballControls](https://threejs.org/docs/pages/TrackballControls.html.md)
+- [TransformControls](https://threejs.org/docs/pages/TransformControls.html.md)
+
+### Helpers
+
+- [ArrowHelper](https://threejs.org/docs/pages/ArrowHelper.html.md)
+- [AxesHelper](https://threejs.org/docs/pages/AxesHelper.html.md)
+- [Box3Helper](https://threejs.org/docs/pages/Box3Helper.html.md)
+- [BoxHelper](https://threejs.org/docs/pages/BoxHelper.html.md)
+- [CCDIKHelper](https://threejs.org/docs/pages/CCDIKHelper.html.md)
+- [CSMHelper](https://threejs.org/docs/pages/CSMHelper.html.md)
+- [CameraHelper](https://threejs.org/docs/pages/CameraHelper.html.md)
+- [DirectionalLightHelper](https://threejs.org/docs/pages/DirectionalLightHelper.html.md)
+- [GridHelper](https://threejs.org/docs/pages/GridHelper.html.md)
+- [HemisphereLightHelper](https://threejs.org/docs/pages/HemisphereLightHelper.html.md)
+- [LightProbeHelper](https://threejs.org/docs/pages/LightProbeHelper.html.md)
+- [OctreeHelper](https://threejs.org/docs/pages/OctreeHelper.html.md)
+- [PlaneHelper](https://threejs.org/docs/pages/PlaneHelper.html.md)
+- [PointLightHelper](https://threejs.org/docs/pages/PointLightHelper.html.md)
+- [PolarGridHelper](https://threejs.org/docs/pages/PolarGridHelper.html.md)
+- [PositionalAudioHelper](https://threejs.org/docs/pages/PositionalAudioHelper.html.md)
+- [RapierHelper](https://threejs.org/docs/pages/RapierHelper.html.md)
+- [RectAreaLightHelper](https://threejs.org/docs/pages/RectAreaLightHelper.html.md)
+- [SelectionHelper](https://threejs.org/docs/pages/SelectionHelper.html.md)
+- [SkeletonHelper](https://threejs.org/docs/pages/SkeletonHelper.html.md)
+- [SpotLightHelper](https://threejs.org/docs/pages/SpotLightHelper.html.md)
+- [TextureHelper](https://threejs.org/docs/pages/TextureHelper.html.md)
+- [TileShadowNodeHelper](https://threejs.org/docs/pages/TileShadowNodeHelper.html.md)
+- [VertexNormalsHelper](https://threejs.org/docs/pages/VertexNormalsHelper.html.md)
+- [VertexTangentsHelper](https://threejs.org/docs/pages/VertexTangentsHelper.html.md)
+- [ViewHelper](https://threejs.org/docs/pages/ViewHelper.html.md)
+
+### Animation
+
+- [AnimationAction](https://threejs.org/docs/pages/AnimationAction.html.md)
+- [AnimationClip](https://threejs.org/docs/pages/AnimationClip.html.md)
+- [AnimationClipCreator](https://threejs.org/docs/pages/AnimationClipCreator.html.md)
+- [AnimationMixer](https://threejs.org/docs/pages/AnimationMixer.html.md)
+- [AnimationObjectGroup](https://threejs.org/docs/pages/AnimationObjectGroup.html.md)
+- [AnimationUtils](https://threejs.org/docs/pages/AnimationUtils.html.md)
+
+### Audio
+
+- [Audio](https://threejs.org/docs/pages/Audio.html.md)
+- [AudioAnalyser](https://threejs.org/docs/pages/AudioAnalyser.html.md)
+- [AudioContext](https://threejs.org/docs/pages/AudioContext.html.md)
+- [AudioListener](https://threejs.org/docs/pages/AudioListener.html.md)
+- [PositionalAudio](https://threejs.org/docs/pages/PositionalAudio.html.md)
+
+### Math
+
+- [Box2](https://threejs.org/docs/pages/Box2.html.md)
+- [Box3](https://threejs.org/docs/pages/Box3.html.md)
+- [Color](https://threejs.org/docs/pages/Color.html.md)
+- [Euler](https://threejs.org/docs/pages/Euler.html.md)
+- [Frustum](https://threejs.org/docs/pages/Frustum.html.md)
+- [FrustumArray](https://threejs.org/docs/pages/FrustumArray.html.md)
+- [Matrix2](https://threejs.org/docs/pages/Matrix2.html.md)
+- [Matrix3](https://threejs.org/docs/pages/Matrix3.html.md)
+- [Matrix4](https://threejs.org/docs/pages/Matrix4.html.md)
+- [Plane](https://threejs.org/docs/pages/Plane.html.md)
+- [Quaternion](https://threejs.org/docs/pages/Quaternion.html.md)
+- [QuaternionKeyframeTrack](https://threejs.org/docs/pages/QuaternionKeyframeTrack.html.md)
+- [QuaternionLinearInterpolant](https://threejs.org/docs/pages/QuaternionLinearInterpolant.html.md)
+- [Ray](https://threejs.org/docs/pages/Ray.html.md)
+- [Raycaster](https://threejs.org/docs/pages/Raycaster.html.md)
+- [Sphere](https://threejs.org/docs/pages/Sphere.html.md)
+- [Triangle](https://threejs.org/docs/pages/Triangle.html.md)
+- [Vector2](https://threejs.org/docs/pages/Vector2.html.md)
+- [Vector3](https://threejs.org/docs/pages/Vector3.html.md)
+- [Vector4](https://threejs.org/docs/pages/Vector4.html.md)
+- [VectorKeyframeTrack](https://threejs.org/docs/pages/VectorKeyframeTrack.html.md)
+
+### Curves
+
+- [ArcCurve](https://threejs.org/docs/pages/ArcCurve.html.md)
+- [CatmullRomCurve3](https://threejs.org/docs/pages/CatmullRomCurve3.html.md)
+- [CubicBezierCurve](https://threejs.org/docs/pages/CubicBezierCurve.html.md)
+- [CubicBezierCurve3](https://threejs.org/docs/pages/CubicBezierCurve3.html.md)
+- [Curve](https://threejs.org/docs/pages/Curve.html.md)
+- [CurvePath](https://threejs.org/docs/pages/CurvePath.html.md)
+- [EllipseCurve](https://threejs.org/docs/pages/EllipseCurve.html.md)
+- [HeartCurve](https://threejs.org/docs/pages/HeartCurve.html.md)
+- [HelixCurve](https://threejs.org/docs/pages/HelixCurve.html.md)
+- [KnotCurve](https://threejs.org/docs/pages/KnotCurve.html.md)
+- [LineCurve](https://threejs.org/docs/pages/LineCurve.html.md)
+- [LineCurve3](https://threejs.org/docs/pages/LineCurve3.html.md)
+- [NURBSCurve](https://threejs.org/docs/pages/NURBSCurve.html.md)
+- [QuadraticBezierCurve](https://threejs.org/docs/pages/QuadraticBezierCurve.html.md)
+- [QuadraticBezierCurve3](https://threejs.org/docs/pages/QuadraticBezierCurve3.html.md)
+- [SplineCurve](https://threejs.org/docs/pages/SplineCurve.html.md)
+- [VivianiCurve](https://threejs.org/docs/pages/VivianiCurve.html.md)
+
+### Effects
+
+- [AnaglyphEffect](https://threejs.org/docs/pages/AnaglyphEffect.html.md)
+- [AsciiEffect](https://threejs.org/docs/pages/AsciiEffect.html.md)
+- [OutlineEffect](https://threejs.org/docs/pages/OutlineEffect.html.md)
+- [ParallaxBarrierEffect](https://threejs.org/docs/pages/ParallaxBarrierEffect.html.md)
+- [StereoEffect](https://threejs.org/docs/pages/StereoEffect.html.md)
+
+### Post-Processing
+
+- [AfterimagePass](https://threejs.org/docs/pages/AfterimagePass.html.md)
+- [AnaglyphPassNode](https://threejs.org/docs/pages/AnaglyphPassNode.html.md)
+- [BloomPass](https://threejs.org/docs/pages/BloomPass.html.md)
+- [BokehPass](https://threejs.org/docs/pages/BokehPass.html.md)
+- [ClearMaskPass](https://threejs.org/docs/pages/ClearMaskPass.html.md)
+- [ClearPass](https://threejs.org/docs/pages/ClearPass.html.md)
+- [CubeTexturePass](https://threejs.org/docs/pages/CubeTexturePass.html.md)
+- [DotScreenPass](https://threejs.org/docs/pages/DotScreenPass.html.md)
+- [FXAAPass](https://threejs.org/docs/pages/FXAAPass.html.md)
+- [FilmPass](https://threejs.org/docs/pages/FilmPass.html.md)
+- [GTAOPass](https://threejs.org/docs/pages/GTAOPass.html.md)
+- [GlitchPass](https://threejs.org/docs/pages/GlitchPass.html.md)
+- [HalftonePass](https://threejs.org/docs/pages/HalftonePass.html.md)
+- [LUTPass](https://threejs.org/docs/pages/LUTPass.html.md)
+- [MaskPass](https://threejs.org/docs/pages/MaskPass.html.md)
+- [OutlinePass](https://threejs.org/docs/pages/OutlinePass.html.md)
+- [OutputPass](https://threejs.org/docs/pages/OutputPass.html.md)
+- [ParallaxBarrierPassNode](https://threejs.org/docs/pages/ParallaxBarrierPassNode.html.md)
+- [Pass](https://threejs.org/docs/pages/Pass.html.md)
+- [PassNode](https://threejs.org/docs/pages/PassNode.html.md)
+- [PixelationPassNode](https://threejs.org/docs/pages/PixelationPassNode.html.md)
+- [ReflectorForSSRPass](https://threejs.org/docs/pages/ReflectorForSSRPass.html.md)
+- [RenderPass](https://threejs.org/docs/pages/RenderPass.html.md)
+- [RenderPixelatedPass](https://threejs.org/docs/pages/RenderPixelatedPass.html.md)
+- [RenderTransitionPass](https://threejs.org/docs/pages/RenderTransitionPass.html.md)
+- [SAOPass](https://threejs.org/docs/pages/SAOPass.html.md)
+- [SMAAPass](https://threejs.org/docs/pages/SMAAPass.html.md)
+- [SSAAPassNode](https://threejs.org/docs/pages/SSAAPassNode.html.md)
+- [SSAARenderPass](https://threejs.org/docs/pages/SSAARenderPass.html.md)
+- [SSAOPass](https://threejs.org/docs/pages/SSAOPass.html.md)
+- [SSRPass](https://threejs.org/docs/pages/SSRPass.html.md)
+- [SavePass](https://threejs.org/docs/pages/SavePass.html.md)
+- [ShaderPass](https://threejs.org/docs/pages/ShaderPass.html.md)
+- [StereoCompositePassNode](https://threejs.org/docs/pages/StereoCompositePassNode.html.md)
+- [StereoPassNode](https://threejs.org/docs/pages/StereoPassNode.html.md)
+- [TAARenderPass](https://threejs.org/docs/pages/TAARenderPass.html.md)
+- [TexturePass](https://threejs.org/docs/pages/TexturePass.html.md)
+- [ToonOutlinePassNode](https://threejs.org/docs/pages/ToonOutlinePassNode.html.md)
+- [UnrealBloomPass](https://threejs.org/docs/pages/UnrealBloomPass.html.md)
+
+### Nodes (TSL)
+
+- [AONode](https://threejs.org/docs/pages/AONode.html.md)
+- [AfterImageNode](https://threejs.org/docs/pages/AfterImageNode.html.md)
+- [AmbientLightNode](https://threejs.org/docs/pages/AmbientLightNode.html.md)
+- [AnalyticLightNode](https://threejs.org/docs/pages/AnalyticLightNode.html.md)
+- [AnamorphicNode](https://threejs.org/docs/pages/AnamorphicNode.html.md)
+- [ArrayElementNode](https://threejs.org/docs/pages/ArrayElementNode.html.md)
+- [ArrayNode](https://threejs.org/docs/pages/ArrayNode.html.md)
+- [AssignNode](https://threejs.org/docs/pages/AssignNode.html.md)
+- [AtomicFunctionNode](https://threejs.org/docs/pages/AtomicFunctionNode.html.md)
+- [AttributeNode](https://threejs.org/docs/pages/AttributeNode.html.md)
+- [BarrierNode](https://threejs.org/docs/pages/BarrierNode.html.md)
+- [BasicEnvironmentNode](https://threejs.org/docs/pages/BasicEnvironmentNode.html.md)
+- [BasicLightMapNode](https://threejs.org/docs/pages/BasicLightMapNode.html.md)
+- [BatchNode](https://threejs.org/docs/pages/BatchNode.html.md)
+- [BitcastNode](https://threejs.org/docs/pages/BitcastNode.html.md)
+- [BitcountNode](https://threejs.org/docs/pages/BitcountNode.html.md)
+- [BloomNode](https://threejs.org/docs/pages/BloomNode.html.md)
+- [BufferAttributeNode](https://threejs.org/docs/pages/BufferAttributeNode.html.md)
+- [BufferNode](https://threejs.org/docs/pages/BufferNode.html.md)
+- [BuiltinNode](https://threejs.org/docs/pages/BuiltinNode.html.md)
+- [BumpMapNode](https://threejs.org/docs/pages/BumpMapNode.html.md)
+- [BypassNode](https://threejs.org/docs/pages/BypassNode.html.md)
+- [CSMShadowNode](https://threejs.org/docs/pages/CSMShadowNode.html.md)
+- [ChromaticAberrationNode](https://threejs.org/docs/pages/ChromaticAberrationNode.html.md)
+- [ClippingNode](https://threejs.org/docs/pages/ClippingNode.html.md)
+- [CodeNode](https://threejs.org/docs/pages/CodeNode.html.md)
+- [ColorSpaceNode](https://threejs.org/docs/pages/ColorSpaceNode.html.md)
+- [ComputeBuiltinNode](https://threejs.org/docs/pages/ComputeBuiltinNode.html.md)
+- [ComputeNode](https://threejs.org/docs/pages/ComputeNode.html.md)
+- [ConditionalNode](https://threejs.org/docs/pages/ConditionalNode.html.md)
+- [ConstNode](https://threejs.org/docs/pages/ConstNode.html.md)
+- [ContextNode](https://threejs.org/docs/pages/ContextNode.html.md)
+- [ConvertNode](https://threejs.org/docs/pages/ConvertNode.html.md)
+- [CubeMapNode](https://threejs.org/docs/pages/CubeMapNode.html.md)
+- [CubeTextureNode](https://threejs.org/docs/pages/CubeTextureNode.html.md)
+- [DenoiseNode](https://threejs.org/docs/pages/DenoiseNode.html.md)
+- [DepthOfFieldNode](https://threejs.org/docs/pages/DepthOfFieldNode.html.md)
+- [DirectionalLightNode](https://threejs.org/docs/pages/DirectionalLightNode.html.md)
+- [DotScreenNode](https://threejs.org/docs/pages/DotScreenNode.html.md)
+- [EnvironmentNode](https://threejs.org/docs/pages/EnvironmentNode.html.md)
+- [EventNode](https://threejs.org/docs/pages/EventNode.html.md)
+- [ExpressionNode](https://threejs.org/docs/pages/ExpressionNode.html.md)
+- [FXAANode](https://threejs.org/docs/pages/FXAANode.html.md)
+- [FilmNode](https://threejs.org/docs/pages/FilmNode.html.md)
+- [FlipNode](https://threejs.org/docs/pages/FlipNode.html.md)
+- [FrontFacingNode](https://threejs.org/docs/pages/FrontFacingNode.html.md)
+- [FunctionCallNode](https://threejs.org/docs/pages/FunctionCallNode.html.md)
+- [FunctionNode](https://threejs.org/docs/pages/FunctionNode.html.md)
+- [FunctionOverloadingNode](https://threejs.org/docs/pages/FunctionOverloadingNode.html.md)
+- [GTAONode](https://threejs.org/docs/pages/GTAONode.html.md)
+- [GaussianBlurNode](https://threejs.org/docs/pages/GaussianBlurNode.html.md)
+- [HemisphereLightNode](https://threejs.org/docs/pages/HemisphereLightNode.html.md)
+- [IESSpotLightNode](https://threejs.org/docs/pages/IESSpotLightNode.html.md)
+- [IndexNode](https://threejs.org/docs/pages/IndexNode.html.md)
+- [InputNode](https://threejs.org/docs/pages/InputNode.html.md)
+- [InspectorNode](https://threejs.org/docs/pages/InspectorNode.html.md)
+- [InstanceNode](https://threejs.org/docs/pages/InstanceNode.html.md)
+- [InstancedMeshNode](https://threejs.org/docs/pages/InstancedMeshNode.html.md)
+- [IrradianceNode](https://threejs.org/docs/pages/IrradianceNode.html.md)
+- [IsolateNode](https://threejs.org/docs/pages/IsolateNode.html.md)
+- [JoinNode](https://threejs.org/docs/pages/JoinNode.html.md)
+- [LensflareNode](https://threejs.org/docs/pages/LensflareNode.html.md)
+- [LightProbeNode](https://threejs.org/docs/pages/LightProbeNode.html.md)
+- [LightingContextNode](https://threejs.org/docs/pages/LightingContextNode.html.md)
+- [LightingNode](https://threejs.org/docs/pages/LightingNode.html.md)
+- [LightsNode](https://threejs.org/docs/pages/LightsNode.html.md)
+- [LoopNode](https://threejs.org/docs/pages/LoopNode.html.md)
+- [Lut3DNode](https://threejs.org/docs/pages/Lut3DNode.html.md)
+- [MRTNode](https://threejs.org/docs/pages/MRTNode.html.md)
+- [MaterialNode](https://threejs.org/docs/pages/MaterialNode.html.md)
+- [MaterialReferenceNode](https://threejs.org/docs/pages/MaterialReferenceNode.html.md)
+- [MathNode](https://threejs.org/docs/pages/MathNode.html.md)
+- [MaxMipLevelNode](https://threejs.org/docs/pages/MaxMipLevelNode.html.md)
+- [MemberNode](https://threejs.org/docs/pages/MemberNode.html.md)
+- [ModelNode](https://threejs.org/docs/pages/ModelNode.html.md)
+- [MorphNode](https://threejs.org/docs/pages/MorphNode.html.md)
+- [Node](https://threejs.org/docs/pages/Node.html.md)
+- [NormalMapNode](https://threejs.org/docs/pages/NormalMapNode.html.md)
+- [Object3DNode](https://threejs.org/docs/pages/Object3DNode.html.md)
+- [OperatorNode](https://threejs.org/docs/pages/OperatorNode.html.md)
+- [OutlineNode](https://threejs.org/docs/pages/OutlineNode.html.md)
+- [OutputStructNode](https://threejs.org/docs/pages/OutputStructNode.html.md)
+- [PMREMNode](https://threejs.org/docs/pages/PMREMNode.html.md)
+- [PackFloatNode](https://threejs.org/docs/pages/PackFloatNode.html.md)
+- [ParameterNode](https://threejs.org/docs/pages/ParameterNode.html.md)
+- [PassMultipleTextureNode](https://threejs.org/docs/pages/PassMultipleTextureNode.html.md)
+- [PassTextureNode](https://threejs.org/docs/pages/PassTextureNode.html.md)
+- [PixelationNode](https://threejs.org/docs/pages/PixelationNode.html.md)
+- [PointLightNode](https://threejs.org/docs/pages/PointLightNode.html.md)
+- [PointShadowNode](https://threejs.org/docs/pages/PointShadowNode.html.md)
+- [PointUVNode](https://threejs.org/docs/pages/PointUVNode.html.md)
+- [PosterizeNode](https://threejs.org/docs/pages/PosterizeNode.html.md)
+- [ProjectorLightNode](https://threejs.org/docs/pages/ProjectorLightNode.html.md)
+- [PropertyNode](https://threejs.org/docs/pages/PropertyNode.html.md)
+- [RGBShiftNode](https://threejs.org/docs/pages/RGBShiftNode.html.md)
+- [RTTNode](https://threejs.org/docs/pages/RTTNode.html.md)
+- [RangeNode](https://threejs.org/docs/pages/RangeNode.html.md)
+- [RectAreaLightNode](https://threejs.org/docs/pages/RectAreaLightNode.html.md)
+- [ReferenceBaseNode](https://threejs.org/docs/pages/ReferenceBaseNode.html.md)
+- [ReferenceElementNode](https://threejs.org/docs/pages/ReferenceElementNode.html.md)
+- [ReferenceNode](https://threejs.org/docs/pages/ReferenceNode.html.md)
+- [ReflectorNode](https://threejs.org/docs/pages/ReflectorNode.html.md)
+- [RemapNode](https://threejs.org/docs/pages/RemapNode.html.md)
+- [RenderOutputNode](https://threejs.org/docs/pages/RenderOutputNode.html.md)
+- [RendererReferenceNode](https://threejs.org/docs/pages/RendererReferenceNode.html.md)
+- [RotateNode](https://threejs.org/docs/pages/RotateNode.html.md)
+- [SMAANode](https://threejs.org/docs/pages/SMAANode.html.md)
+- [SSGINode](https://threejs.org/docs/pages/SSGINode.html.md)
+- [SSRNode](https://threejs.org/docs/pages/SSRNode.html.md)
+- [SSSNode](https://threejs.org/docs/pages/SSSNode.html.md)
+- [SampleNode](https://threejs.org/docs/pages/SampleNode.html.md)
+- [SceneNode](https://threejs.org/docs/pages/SceneNode.html.md)
+- [ScreenNode](https://threejs.org/docs/pages/ScreenNode.html.md)
+- [ScriptableNode](https://threejs.org/docs/pages/ScriptableNode.html.md)
+- [ScriptableValueNode](https://threejs.org/docs/pages/ScriptableValueNode.html.md)
+- [SetNode](https://threejs.org/docs/pages/SetNode.html.md)
+- [ShadowBaseNode](https://threejs.org/docs/pages/ShadowBaseNode.html.md)
+- [ShadowNode](https://threejs.org/docs/pages/ShadowNode.html.md)
+- [SkinningNode](https://threejs.org/docs/pages/SkinningNode.html.md)
+- [SobelOperatorNode](https://threejs.org/docs/pages/SobelOperatorNode.html.md)
+- [SplitNode](https://threejs.org/docs/pages/SplitNode.html.md)
+- [SpotLightNode](https://threejs.org/docs/pages/SpotLightNode.html.md)
+- [SpriteSheetUVNode](https://threejs.org/docs/pages/SpriteSheetUVNode.html.md)
+- [StackNode](https://threejs.org/docs/pages/StackNode.html.md)
+- [StorageArrayElementNode](https://threejs.org/docs/pages/StorageArrayElementNode.html.md)
+- [StorageBufferNode](https://threejs.org/docs/pages/StorageBufferNode.html.md)
+- [StorageTextureNode](https://threejs.org/docs/pages/StorageTextureNode.html.md)
+- [StructNode](https://threejs.org/docs/pages/StructNode.html.md)
+- [StructTypeNode](https://threejs.org/docs/pages/StructTypeNode.html.md)
+- [SubBuildNode](https://threejs.org/docs/pages/SubBuildNode.html.md)
+- [SubgroupFunctionNode](https://threejs.org/docs/pages/SubgroupFunctionNode.html.md)
+- [TRAANode](https://threejs.org/docs/pages/TRAANode.html.md)
+- [TempNode](https://threejs.org/docs/pages/TempNode.html.md)
+- [Texture3DNode](https://threejs.org/docs/pages/Texture3DNode.html.md)
+- [TextureNode](https://threejs.org/docs/pages/TextureNode.html.md)
+- [TextureSizeNode](https://threejs.org/docs/pages/TextureSizeNode.html.md)
+- [TileShadowNode](https://threejs.org/docs/pages/TileShadowNode.html.md)
+- [TiledLightsNode](https://threejs.org/docs/pages/TiledLightsNode.html.md)
+- [ToneMappingNode](https://threejs.org/docs/pages/ToneMappingNode.html.md)
+- [TransitionNode](https://threejs.org/docs/pages/TransitionNode.html.md)
+- [UniformArrayElementNode](https://threejs.org/docs/pages/UniformArrayElementNode.html.md)
+- [UniformArrayNode](https://threejs.org/docs/pages/UniformArrayNode.html.md)
+- [UniformGroupNode](https://threejs.org/docs/pages/UniformGroupNode.html.md)
+- [UniformNode](https://threejs.org/docs/pages/UniformNode.html.md)
+- [UnpackFloatNode](https://threejs.org/docs/pages/UnpackFloatNode.html.md)
+- [UserDataNode](https://threejs.org/docs/pages/UserDataNode.html.md)
+- [VarNode](https://threejs.org/docs/pages/VarNode.html.md)
+- [VaryingNode](https://threejs.org/docs/pages/VaryingNode.html.md)
+- [VelocityNode](https://threejs.org/docs/pages/VelocityNode.html.md)
+- [VertexColorNode](https://threejs.org/docs/pages/VertexColorNode.html.md)
+- [ViewportDepthNode](https://threejs.org/docs/pages/ViewportDepthNode.html.md)
+- [ViewportDepthTextureNode](https://threejs.org/docs/pages/ViewportDepthTextureNode.html.md)
+- [ViewportSharedTextureNode](https://threejs.org/docs/pages/ViewportSharedTextureNode.html.md)
+- [ViewportTextureNode](https://threejs.org/docs/pages/ViewportTextureNode.html.md)
+- [WorkgroupInfoElementNode](https://threejs.org/docs/pages/WorkgroupInfoElementNode.html.md)
+- [WorkgroupInfoNode](https://threejs.org/docs/pages/WorkgroupInfoNode.html.md)
+
+### WebXR
+
+- [EXRExporter](https://threejs.org/docs/pages/EXRExporter.html.md)
+- [WebXRDepthSensing](https://threejs.org/docs/pages/WebXRDepthSensing.html.md)
+- [WebXRManager](https://threejs.org/docs/pages/WebXRManager.html.md)
+- [XRButton](https://threejs.org/docs/pages/XRButton.html.md)
+- [XRControllerModel](https://threejs.org/docs/pages/XRControllerModel.html.md)
+- [XRControllerModelFactory](https://threejs.org/docs/pages/XRControllerModelFactory.html.md)
+- [XRHandMeshModel](https://threejs.org/docs/pages/XRHandMeshModel.html.md)
+- [XRHandModel](https://threejs.org/docs/pages/XRHandModel.html.md)
+- [XRHandModelFactory](https://threejs.org/docs/pages/XRHandModelFactory.html.md)
+- [XRHandPrimitiveModel](https://threejs.org/docs/pages/XRHandPrimitiveModel.html.md)
+- [XRManager](https://threejs.org/docs/pages/XRManager.html.md)
+- [XRPlanes](https://threejs.org/docs/pages/XRPlanes.html.md)
+
+### Shader Modules
+
+- [module-ACESFilmicToneMappingShader](https://threejs.org/docs/pages/module-ACESFilmicToneMappingShader.html.md)
+- [module-AfterimageShader](https://threejs.org/docs/pages/module-AfterimageShader.html.md)
+- [module-BasicShader](https://threejs.org/docs/pages/module-BasicShader.html.md)
+- [module-Bayer](https://threejs.org/docs/pages/module-Bayer.html.md)
+- [module-BleachBypassShader](https://threejs.org/docs/pages/module-BleachBypassShader.html.md)
+- [module-BlendShader](https://threejs.org/docs/pages/module-BlendShader.html.md)
+- [module-BokehShader](https://threejs.org/docs/pages/module-BokehShader.html.md)
+- [module-BokehShader2](https://threejs.org/docs/pages/module-BokehShader2.html.md)
+- [module-BrightnessContrastShader](https://threejs.org/docs/pages/module-BrightnessContrastShader.html.md)
+- [module-BufferGeometryUtils](https://threejs.org/docs/pages/module-BufferGeometryUtils.html.md)
+- [module-CSMShader](https://threejs.org/docs/pages/module-CSMShader.html.md)
+- [module-CameraUtils](https://threejs.org/docs/pages/module-CameraUtils.html.md)
+- [module-ColorCorrectionShader](https://threejs.org/docs/pages/module-ColorCorrectionShader.html.md)
+- [module-ColorSpaces](https://threejs.org/docs/pages/module-ColorSpaces.html.md)
+- [module-ColorifyShader](https://threejs.org/docs/pages/module-ColorifyShader.html.md)
+- [module-ConvolutionShader](https://threejs.org/docs/pages/module-ConvolutionShader.html.md)
+- [module-CopyShader](https://threejs.org/docs/pages/module-CopyShader.html.md)
+- [module-DOFMipMapShader](https://threejs.org/docs/pages/module-DOFMipMapShader.html.md)
+- [module-DepthLimitedBlurShader](https://threejs.org/docs/pages/module-DepthLimitedBlurShader.html.md)
+- [module-DigitalGlitch](https://threejs.org/docs/pages/module-DigitalGlitch.html.md)
+- [module-DotScreenShader](https://threejs.org/docs/pages/module-DotScreenShader.html.md)
+- [module-ExposureShader](https://threejs.org/docs/pages/module-ExposureShader.html.md)
+- [module-FXAAShader](https://threejs.org/docs/pages/module-FXAAShader.html.md)
+- [module-FilmShader](https://threejs.org/docs/pages/module-FilmShader.html.md)
+- [module-FocusShader](https://threejs.org/docs/pages/module-FocusShader.html.md)
+- [module-FreiChenShader](https://threejs.org/docs/pages/module-FreiChenShader.html.md)
+- [module-GTAOShader](https://threejs.org/docs/pages/module-GTAOShader.html.md)
+- [module-GammaCorrectionShader](https://threejs.org/docs/pages/module-GammaCorrectionShader.html.md)
+- [module-GeometryCompressionUtils](https://threejs.org/docs/pages/module-GeometryCompressionUtils.html.md)
+- [module-GeometryUtils](https://threejs.org/docs/pages/module-GeometryUtils.html.md)
+- [module-GodRaysShader](https://threejs.org/docs/pages/module-GodRaysShader.html.md)
+- [module-HalftoneShader](https://threejs.org/docs/pages/module-HalftoneShader.html.md)
+- [module-HorizontalBlurShader](https://threejs.org/docs/pages/module-HorizontalBlurShader.html.md)
+- [module-HorizontalTiltShiftShader](https://threejs.org/docs/pages/module-HorizontalTiltShiftShader.html.md)
+- [module-HueSaturationShader](https://threejs.org/docs/pages/module-HueSaturationShader.html.md)
+- [module-Interpolations](https://threejs.org/docs/pages/module-Interpolations.html.md)
+- [module-KaleidoShader](https://threejs.org/docs/pages/module-KaleidoShader.html.md)
+- [module-LuminosityHighPassShader](https://threejs.org/docs/pages/module-LuminosityHighPassShader.html.md)
+- [module-LuminosityShader](https://threejs.org/docs/pages/module-LuminosityShader.html.md)
+- [module-MirrorShader](https://threejs.org/docs/pages/module-MirrorShader.html.md)
+- [module-NURBSUtils](https://threejs.org/docs/pages/module-NURBSUtils.html.md)
+- [module-NormalMapShader](https://threejs.org/docs/pages/module-NormalMapShader.html.md)
+- [module-OutputShader](https://threejs.org/docs/pages/module-OutputShader.html.md)
+- [module-ParametricFunctions](https://threejs.org/docs/pages/module-ParametricFunctions.html.md)
+- [module-PoissonDenoiseShader](https://threejs.org/docs/pages/module-PoissonDenoiseShader.html.md)
+- [module-RGBShiftShader](https://threejs.org/docs/pages/module-RGBShiftShader.html.md)
+- [module-Raymarching](https://threejs.org/docs/pages/module-Raymarching.html.md)
+- [module-SAOShader](https://threejs.org/docs/pages/module-SAOShader.html.md)
+- [module-SMAAShader](https://threejs.org/docs/pages/module-SMAAShader.html.md)
+- [module-SSAOShader](https://threejs.org/docs/pages/module-SSAOShader.html.md)
+- [module-SSRShader](https://threejs.org/docs/pages/module-SSRShader.html.md)
+- [module-SceneUtils](https://threejs.org/docs/pages/module-SceneUtils.html.md)
+- [module-SepiaShader](https://threejs.org/docs/pages/module-SepiaShader.html.md)
+- [module-SkeletonUtils](https://threejs.org/docs/pages/module-SkeletonUtils.html.md)
+- [module-SobelOperatorShader](https://threejs.org/docs/pages/module-SobelOperatorShader.html.md)
+- [module-SortUtils](https://threejs.org/docs/pages/module-SortUtils.html.md)
+- [module-SubsurfaceScatteringShader](https://threejs.org/docs/pages/module-SubsurfaceScatteringShader.html.md)
+- [module-Text2D](https://threejs.org/docs/pages/module-Text2D.html.md)
+- [module-TriangleBlurShader](https://threejs.org/docs/pages/module-TriangleBlurShader.html.md)
+- [module-UVsDebug](https://threejs.org/docs/pages/module-UVsDebug.html.md)
+- [module-UniformsUtils](https://threejs.org/docs/pages/module-UniformsUtils.html.md)
+- [module-UnpackDepthRGBAShader](https://threejs.org/docs/pages/module-UnpackDepthRGBAShader.html.md)
+- [module-VelocityShader](https://threejs.org/docs/pages/module-VelocityShader.html.md)
+- [module-VerticalBlurShader](https://threejs.org/docs/pages/module-VerticalBlurShader.html.md)
+- [module-VerticalTiltShiftShader](https://threejs.org/docs/pages/module-VerticalTiltShiftShader.html.md)
+- [module-VignetteShader](https://threejs.org/docs/pages/module-VignetteShader.html.md)
+- [module-VolumeShader](https://threejs.org/docs/pages/module-VolumeShader.html.md)
+- [module-WaterRefractionShader](https://threejs.org/docs/pages/module-WaterRefractionShader.html.md)
+- [module-WebGLTextureUtils](https://threejs.org/docs/pages/module-WebGLTextureUtils.html.md)
+- [module-WebGPUTextureUtils](https://threejs.org/docs/pages/module-WebGPUTextureUtils.html.md)
diff --git a/docs/llms.txt b/docs/llms.txt
new file mode 100644
index 00000000000000..8f52da57d52578
--- /dev/null
+++ b/docs/llms.txt
@@ -0,0 +1,158 @@
+# Three.js
+
+> Three.js is a cross-browser JavaScript library for creating 3D graphics using WebGL and WebGPU.
+
+## Instructions for Large Language Models
+
+When generating Three.js code, follow these guidelines:
+
+### 1. Use Import Maps (Not Old CDN Patterns)
+
+WRONG - outdated pattern:
+```html
+
+```
+
+CORRECT - modern pattern (always use latest version):
+```html
+
+
+```
+
+### 2. Choosing Between WebGLRenderer and WebGPURenderer
+
+Three.js maintains both renderers:
+
+**Use WebGLRenderer** (default, mature):
+- Maximum browser compatibility
+- Well-established, many years of development
+- Most examples and tutorials use this
+
+```js
+import * as THREE from 'three';
+const renderer = new THREE.WebGLRenderer();
+```
+
+**Use WebGPURenderer** when you need:
+- Custom shaders/materials using TSL (Three.js Shading Language)
+- Compute shaders
+- Advanced node-based materials
+
+```js
+import * as THREE from 'three/webgpu';
+const renderer = new THREE.WebGPURenderer();
+await renderer.init();
+```
+
+### 3. TSL (Three.js Shading Language)
+
+When using WebGPURenderer, use TSL instead of raw GLSL for custom materials:
+
+```js
+import { texture, uv, color } from 'three/tsl';
+
+const material = new THREE.MeshStandardNodeMaterial();
+material.colorNode = texture( myTexture ).mul( color( 0xff0000 ) );
+```
+
+TSL benefits:
+- Works with both WebGL and WebGPU backends
+- No string manipulation or onBeforeCompile hacks
+- Type-safe, composable shader nodes
+- Automatic optimization
+
+### 4. NodeMaterial Classes (for WebGPU/TSL)
+
+When using TSL, use node-based materials:
+- MeshBasicNodeMaterial
+- MeshStandardNodeMaterial
+- MeshPhysicalNodeMaterial
+- LineBasicNodeMaterial
+- SpriteNodeMaterial
+
+## Getting Started
+
+- [Installation](https://threejs.org/manual/#en/installation)
+- [Creating a Scene](https://threejs.org/manual/#en/creating-a-scene)
+- [Fundamentals](https://threejs.org/manual/#en/fundamentals)
+- [Responsive Design](https://threejs.org/manual/#en/responsive)
+
+## Renderer Guides
+
+- [WebGPURenderer](https://threejs.org/manual/#en/webgpurenderer)
+
+## Core Concepts
+
+- [TSL Specification](https://threejs.org/docs/#api/en/nodes/TSL): Complete shader language reference
+- [Animation System](https://threejs.org/manual/#en/animation-system)
+- [Loading 3D Models](https://threejs.org/manual/#en/loading-3d-models)
+- [Scene Graph](https://threejs.org/manual/#en/scenegraph)
+- [Materials](https://threejs.org/manual/#en/materials)
+- [Textures](https://threejs.org/manual/#en/textures)
+- [Lights](https://threejs.org/manual/#en/lights)
+- [Cameras](https://threejs.org/manual/#en/cameras)
+- [Shadows](https://threejs.org/manual/#en/shadows)
+
+## Essential API
+
+### Core
+- [Object3D](https://threejs.org/docs/#api/en/core/Object3D)
+- [BufferGeometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
+- [BufferAttribute](https://threejs.org/docs/#api/en/core/BufferAttribute)
+
+### Scenes
+- [Scene](https://threejs.org/docs/#api/en/scenes/Scene)
+
+### Cameras
+- [PerspectiveCamera](https://threejs.org/docs/#api/en/cameras/PerspectiveCamera)
+- [OrthographicCamera](https://threejs.org/docs/#api/en/cameras/OrthographicCamera)
+
+### Renderers
+- [WebGLRenderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
+- [WebGPURenderer](https://threejs.org/docs/#api/en/renderers/webgpu/WebGPURenderer)
+
+### Objects
+- [Mesh](https://threejs.org/docs/#api/en/objects/Mesh)
+- [InstancedMesh](https://threejs.org/docs/#api/en/objects/InstancedMesh)
+- [Group](https://threejs.org/docs/#api/en/objects/Group)
+
+### Materials
+- [MeshBasicMaterial](https://threejs.org/docs/#api/en/materials/MeshBasicMaterial)
+- [MeshStandardMaterial](https://threejs.org/docs/#api/en/materials/MeshStandardMaterial)
+- [MeshPhysicalMaterial](https://threejs.org/docs/#api/en/materials/MeshPhysicalMaterial)
+
+### Geometries
+- [BoxGeometry](https://threejs.org/docs/#api/en/geometries/BoxGeometry)
+- [SphereGeometry](https://threejs.org/docs/#api/en/geometries/SphereGeometry)
+- [PlaneGeometry](https://threejs.org/docs/#api/en/geometries/PlaneGeometry)
+
+### Lights
+- [AmbientLight](https://threejs.org/docs/#api/en/lights/AmbientLight)
+- [DirectionalLight](https://threejs.org/docs/#api/en/lights/DirectionalLight)
+- [PointLight](https://threejs.org/docs/#api/en/lights/PointLight)
+- [SpotLight](https://threejs.org/docs/#api/en/lights/SpotLight)
+
+### Loaders
+- [TextureLoader](https://threejs.org/docs/#api/en/loaders/TextureLoader)
+- [GLTFLoader](https://threejs.org/docs/#examples/en/loaders/GLTFLoader)
+
+### Controls
+- [OrbitControls](https://threejs.org/docs/#examples/en/controls/OrbitControls)
+- [TransformControls](https://threejs.org/docs/#examples/en/controls/TransformControls)
+
+### Math
+- [Vector2](https://threejs.org/docs/#api/en/math/Vector2)
+- [Vector3](https://threejs.org/docs/#api/en/math/Vector3)
+- [Matrix4](https://threejs.org/docs/#api/en/math/Matrix4)
+- [Quaternion](https://threejs.org/docs/#api/en/math/Quaternion)
+- [Color](https://threejs.org/docs/#api/en/math/Color)
diff --git a/docs/pages/AMFLoader.html.md b/docs/pages/AMFLoader.html.md
new file mode 100644
index 00000000000000..fb4700738ac1df
--- /dev/null
+++ b/docs/pages/AMFLoader.html.md
@@ -0,0 +1,73 @@
+*Inheritance: Loader →*
+
+# AMFLoader
+
+A loader for the AMF format.
+
+The loader supports materials, color and ZIP compressed files. No constellation support (yet).
+
+## Code Example
+
+```js
+const loader = new AMFLoader();
+const object = await loader.loadAsync( './models/amf/rook.amf' );
+scene.add( object );
+```
+
+## Import
+
+AMFLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { AMFLoader } from 'three/addons/loaders/AMFLoader.js';
+```
+
+## Constructor
+
+### new AMFLoader( manager : LoadingManager )
+
+Constructs a new AMF loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded AMF asset to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( data : ArrayBuffer ) : Group
+
+Parses the given AMF data and returns the resulting group.
+
+**data**
+
+The raw AMF asset data as an array buffer.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** A group representing the parsed asset.
+
+## Source
+
+[examples/jsm/loaders/AMFLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/AMFLoader.js)
\ No newline at end of file
diff --git a/docs/pages/AONode.html.md b/docs/pages/AONode.html.md
new file mode 100644
index 00000000000000..73d2f4bb6cc3e2
--- /dev/null
+++ b/docs/pages/AONode.html.md
@@ -0,0 +1,29 @@
+*Inheritance: EventDispatcher → Node → LightingNode →*
+
+# AONode
+
+A generic class that can be used by nodes which contribute ambient occlusion to the scene. E.g. an ambient occlusion map node can be used as input for this module. Used in [NodeMaterial](NodeMaterial.html).
+
+## Constructor
+
+### new AONode( aoNode : Node. )
+
+Constructs a new AO node.
+
+**aoNode**
+
+The ambient occlusion node.
+
+Default is `null`.
+
+## Properties
+
+### .aoNode : Node.
+
+The ambient occlusion node.
+
+Default is `null`.
+
+## Source
+
+[src/nodes/lighting/AONode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/lighting/AONode.js)
\ No newline at end of file
diff --git a/docs/pages/ARButton.html.md b/docs/pages/ARButton.html.md
new file mode 100644
index 00000000000000..2f190e000a3a8b
--- /dev/null
+++ b/docs/pages/ARButton.html.md
@@ -0,0 +1,37 @@
+# ARButton
+
+A utility class for creating a button that allows to initiate immersive AR sessions based on WebXR. The button can be created with a factory method and then appended ot the website's DOM.
+
+## Code Example
+
+```js
+document.body.appendChild( ARButton.createButton( renderer ) );
+```
+
+## Import
+
+ARButton is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { ARButton } from 'three/addons/webxr/ARButton.js';
+```
+
+## Static Methods
+
+### .createButton( renderer : WebGLRenderer | WebGPURenderer, sessionInit : XRSessionInit ) : HTMLElement
+
+Constructs a new AR button.
+
+**renderer**
+
+The renderer.
+
+**sessionInit**
+
+The a configuration object for the AR session.
+
+**Returns:** The button or an error message if `immersive-ar` isn't supported.
+
+## Source
+
+[examples/jsm/webxr/ARButton.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/webxr/ARButton.js)
\ No newline at end of file
diff --git a/docs/pages/AfterImageNode.html.md b/docs/pages/AfterImageNode.html.md
new file mode 100644
index 00000000000000..f122ff2caf9332
--- /dev/null
+++ b/docs/pages/AfterImageNode.html.md
@@ -0,0 +1,97 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# AfterImageNode
+
+Post processing node for creating an after image effect.
+
+## Import
+
+AfterImageNode is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { afterImage } from 'three/addons/tsl/display/AfterImageNode.js';
+```
+
+## Constructor
+
+### new AfterImageNode( textureNode : TextureNode, damp : Node. )
+
+Constructs a new after image node.
+
+**textureNode**
+
+The texture node that represents the input of the effect.
+
+**damp**
+
+The damping intensity. A higher value means a stronger after image effect.
+
+Default is `0.96`.
+
+## Properties
+
+### .damp : Node.
+
+How quickly the after-image fades. A higher value means the after-image persists longer, while a lower value means it fades faster. Should be in the range `[0, 1]`.
+
+### .textureNode : TextureNode
+
+The texture node that represents the input of the effect.
+
+### .updateBeforeType : string
+
+The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node renders its effect once per frame in `updateBefore()`.
+
+Default is `'frame'`.
+
+**Overrides:** [TempNode#updateBeforeType](TempNode.html#updateBeforeType)
+
+## Methods
+
+### .dispose()
+
+Frees internal resources. This method should be called when the effect is no longer required.
+
+**Overrides:** [TempNode#dispose](TempNode.html#dispose)
+
+### .getTextureNode() : PassTextureNode
+
+Returns the result of the effect as a texture node.
+
+**Returns:** A texture node that represents the result of the effect.
+
+### .setSize( width : number, height : number )
+
+Sets the size of the effect.
+
+**width**
+
+The width of the effect.
+
+**height**
+
+The height of the effect.
+
+### .setup( builder : NodeBuilder ) : PassTextureNode
+
+This method is used to setup the effect's TSL code.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#setup](TempNode.html#setup)
+
+### .updateBefore( frame : NodeFrame )
+
+This method is used to render the effect once per frame.
+
+**frame**
+
+The current node frame.
+
+**Overrides:** [TempNode#updateBefore](TempNode.html#updateBefore)
+
+## Source
+
+[examples/jsm/tsl/display/AfterImageNode.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/tsl/display/AfterImageNode.js)
\ No newline at end of file
diff --git a/docs/pages/AfterimagePass.html.md b/docs/pages/AfterimagePass.html.md
new file mode 100644
index 00000000000000..7b8366a8079c7f
--- /dev/null
+++ b/docs/pages/AfterimagePass.html.md
@@ -0,0 +1,106 @@
+*Inheritance: Pass →*
+
+# AfterimagePass
+
+Pass for a basic after image effect.
+
+## Code Example
+
+```js
+const afterimagePass = new AfterimagePass( 0.9 );
+composer.addPass( afterimagePass );
+```
+
+## Import
+
+AfterimagePass is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { AfterimagePass } from 'three/addons/postprocessing/AfterimagePass.js';
+```
+
+## Constructor
+
+### new AfterimagePass( damp : number )
+
+Constructs a new after image pass.
+
+**damp**
+
+The damping intensity. A higher value means a stronger after image effect.
+
+Default is `0.96`.
+
+## Properties
+
+### .compFsMaterial : ShaderMaterial
+
+The composition material.
+
+### .copyFsMaterial : ShaderMaterial
+
+The copy material.
+
+### .damp : number
+
+The damping intensity, from 0.0 to 1.0. A higher value means a stronger after image effect.
+
+### .uniforms : Object
+
+The pass uniforms. Use this object if you want to update the `damp` value at runtime.
+
+```js
+pass.uniforms.damp.value = 0.9;
+```
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever the pass is no longer used in your app.
+
+**Overrides:** [Pass#dispose](Pass.html#dispose)
+
+### .render( renderer : WebGLRenderer, writeBuffer : WebGLRenderTarget, readBuffer : WebGLRenderTarget, deltaTime : number, maskActive : boolean )
+
+Performs the after image pass.
+
+**renderer**
+
+The renderer.
+
+**writeBuffer**
+
+The write buffer. This buffer is intended as the rendering destination for the pass.
+
+**readBuffer**
+
+The read buffer. The pass can access the result from the previous pass from this buffer.
+
+**deltaTime**
+
+The delta time in seconds.
+
+**maskActive**
+
+Whether masking is active or not.
+
+**Overrides:** [Pass#render](Pass.html#render)
+
+### .setSize( width : number, height : number )
+
+Sets the size of the pass.
+
+**width**
+
+The width to set.
+
+**height**
+
+The height to set.
+
+**Overrides:** [Pass#setSize](Pass.html#setSize)
+
+## Source
+
+[examples/jsm/postprocessing/AfterimagePass.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/AfterimagePass.js)
\ No newline at end of file
diff --git a/docs/pages/AmbientLight.html.md b/docs/pages/AmbientLight.html.md
new file mode 100644
index 00000000000000..83155f7ba57bb5
--- /dev/null
+++ b/docs/pages/AmbientLight.html.md
@@ -0,0 +1,44 @@
+*Inheritance: EventDispatcher → Object3D → Light →*
+
+# AmbientLight
+
+This light globally illuminates all objects in the scene equally.
+
+It cannot be used to cast shadows as it does not have a direction.
+
+## Code Example
+
+```js
+const light = new THREE.AmbientLight( 0x404040 ); // soft white light
+scene.add( light );
+```
+
+## Constructor
+
+### new AmbientLight( color : number | Color | string, intensity : number )
+
+Constructs a new ambient light.
+
+**color**
+
+The light's color.
+
+Default is `0xffffff`.
+
+**intensity**
+
+The light's strength/intensity.
+
+Default is `1`.
+
+## Properties
+
+### .isAmbientLight : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/lights/AmbientLight.js](https://github.com/mrdoob/three.js/blob/master/src/lights/AmbientLight.js)
\ No newline at end of file
diff --git a/docs/pages/AmbientLightNode.html.md b/docs/pages/AmbientLightNode.html.md
new file mode 100644
index 00000000000000..bc317576e38c39
--- /dev/null
+++ b/docs/pages/AmbientLightNode.html.md
@@ -0,0 +1,21 @@
+*Inheritance: EventDispatcher → Node → LightingNode → AnalyticLightNode →*
+
+# AmbientLightNode
+
+Module for representing ambient lights as nodes.
+
+## Constructor
+
+### new AmbientLightNode( light : AmbientLight )
+
+Constructs a new ambient light node.
+
+**light**
+
+The ambient light source.
+
+Default is `null`.
+
+## Source
+
+[src/nodes/lighting/AmbientLightNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/lighting/AmbientLightNode.js)
\ No newline at end of file
diff --git a/docs/pages/AmmoPhysics.html.md b/docs/pages/AmmoPhysics.html.md
new file mode 100644
index 00000000000000..60c4049ab99c54
--- /dev/null
+++ b/docs/pages/AmmoPhysics.html.md
@@ -0,0 +1,79 @@
+# AmmoPhysics
+
+Can be used to include Ammo.js as a Physics engine into `three.js` apps. Make sure to include `ammo.wasm.js` first:
+
+It is then possible to initialize the API via:
+
+```js
+const physics = await AmmoPhysics();
+```
+
+## Code Example
+
+```js
+
+```
+
+## Import
+
+AmmoPhysics is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { AmmoPhysics } from 'three/addons/physics/AmmoPhysics.js';
+```
+
+## Methods
+
+### .addMesh( mesh : Mesh, mass : number, restitution : number )
+
+Adds the given mesh to this physics simulation.
+
+**mesh**
+
+The mesh to add.
+
+**mass**
+
+The mass in kg of the mesh.
+
+Default is `0`.
+
+**restitution**
+
+The restitution of the mesh, usually from 0 to 1. Represents how "bouncy" objects are when they collide with each other.
+
+Default is `0`.
+
+### .addScene( scene : Object3D )
+
+Adds the given scene to this physics simulation. Only meshes with a `physics` object in their [Object3D#userData](Object3D.html#userData) field will be honored. The object can be used to store the mass of the mesh. E.g.:
+
+```js
+box.userData.physics = { mass: 1 };
+```
+
+**scene**
+
+The scene or any type of 3D object to add.
+
+### .setMeshPosition( mesh : Mesh, position : Vector3, index : number )
+
+Set the position of the given mesh which is part of the physics simulation. Calling this method will reset the current simulated velocity of the mesh.
+
+**mesh**
+
+The mesh to update the position for.
+
+**position**
+
+The new position.
+
+**index**
+
+If the mesh is instanced, the index represents the instanced ID.
+
+Default is `0`.
+
+## Source
+
+[examples/jsm/physics/AmmoPhysics.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/physics/AmmoPhysics.js)
\ No newline at end of file
diff --git a/docs/pages/AnaglyphEffect.html.md b/docs/pages/AnaglyphEffect.html.md
new file mode 100644
index 00000000000000..c4fa6aa5d17ba4
--- /dev/null
+++ b/docs/pages/AnaglyphEffect.html.md
@@ -0,0 +1,69 @@
+# AnaglyphEffect
+
+A class that creates an anaglyph effect.
+
+Note that this class can only be used with [WebGLRenderer](WebGLRenderer.html). When using [WebGPURenderer](WebGPURenderer.html), use [AnaglyphPassNode](AnaglyphPassNode.html).
+
+## Import
+
+AnaglyphEffect is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { AnaglyphEffect } from 'three/addons/effects/AnaglyphEffect.js';
+```
+
+## Constructor
+
+### new AnaglyphEffect( renderer : WebGLRenderer, width : number, height : number )
+
+Constructs a new anaglyph effect.
+
+**renderer**
+
+The renderer.
+
+**width**
+
+The width of the effect in physical pixels.
+
+Default is `512`.
+
+**height**
+
+The height of the effect in physical pixels.
+
+Default is `512`.
+
+## Methods
+
+### .dispose()
+
+Frees internal resources. This method should be called when the effect is no longer required.
+
+### .render( scene : Object3D, camera : Camera )
+
+When using this effect, this method should be called instead of the default [WebGLRenderer#render](WebGLRenderer.html#render).
+
+**scene**
+
+The scene to render.
+
+**camera**
+
+The camera.
+
+### .setSize( width : number, height : number )
+
+Resizes the effect.
+
+**width**
+
+The width of the effect in logical pixels.
+
+**height**
+
+The height of the effect in logical pixels.
+
+## Source
+
+[examples/jsm/effects/AnaglyphEffect.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/effects/AnaglyphEffect.js)
\ No newline at end of file
diff --git a/docs/pages/AnaglyphPassNode.html.md b/docs/pages/AnaglyphPassNode.html.md
new file mode 100644
index 00000000000000..795e1d0b2a0ecb
--- /dev/null
+++ b/docs/pages/AnaglyphPassNode.html.md
@@ -0,0 +1,51 @@
+*Inheritance: EventDispatcher → Node → TempNode → PassNode → StereoCompositePassNode →*
+
+# AnaglyphPassNode
+
+A render pass node that creates an anaglyph effect.
+
+## Import
+
+AnaglyphPassNode is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { anaglyphPass } from 'three/addons/tsl/display/AnaglyphPassNode.js';
+```
+
+## Constructor
+
+### new AnaglyphPassNode( scene : Scene, camera : Camera )
+
+Constructs a new anaglyph pass node.
+
+**scene**
+
+The scene to render.
+
+**camera**
+
+The camera to render the scene with.
+
+## Properties
+
+### .isAnaglyphPassNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Methods
+
+### .setup( builder : NodeBuilder ) : PassTextureNode
+
+This method is used to setup the effect's TSL code.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [StereoCompositePassNode#setup](StereoCompositePassNode.html#setup)
+
+## Source
+
+[examples/jsm/tsl/display/AnaglyphPassNode.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/tsl/display/AnaglyphPassNode.js)
\ No newline at end of file
diff --git a/docs/pages/AnalyticLightNode.html.md b/docs/pages/AnalyticLightNode.html.md
new file mode 100644
index 00000000000000..10b918f4d456b7
--- /dev/null
+++ b/docs/pages/AnalyticLightNode.html.md
@@ -0,0 +1,139 @@
+*Inheritance: EventDispatcher → Node → LightingNode →*
+
+# AnalyticLightNode
+
+Base class for analytic light nodes.
+
+## Constructor
+
+### new AnalyticLightNode( light : Light )
+
+Constructs a new analytic light node.
+
+**light**
+
+The light source.
+
+Default is `null`.
+
+## Properties
+
+### .baseColorNode : Node
+
+This property is used to retain a reference to the original value of [AnalyticLightNode#colorNode](AnalyticLightNode.html#colorNode). The final color node is represented by a different node when using shadows.
+
+Default is `null`.
+
+### .color : Color
+
+The light's color value.
+
+### .colorNode : Node
+
+The light's color node. Points to `colorNode` of the light source, if set. Otherwise it creates a uniform node based on [AnalyticLightNode#color](AnalyticLightNode.html#color).
+
+### .isAnalyticLightNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .light : Light
+
+The light source.
+
+Default is `null`.
+
+### .shadowColorNode : Node
+
+Represents the light's shadow color.
+
+Default is `null`.
+
+### .shadowNode : ShadowNode
+
+Represents the light's shadow.
+
+Default is `null`.
+
+### .updateType : string
+
+Overwritten since analytic light nodes are updated once per frame.
+
+Default is `'frame'`.
+
+**Overrides:** [LightingNode#updateType](LightingNode.html#updateType)
+
+## Methods
+
+### .disposeShadow()
+
+Frees internal resources related to shadows.
+
+### .getLightVector( builder : NodeBuilder ) : Node.
+
+Returns a node representing a direction vector which points from the current position in view space to the light's position in view space.
+
+**builder**
+
+The builder object used for setting up the light.
+
+**Returns:** The light vector node.
+
+### .setup( builder : NodeBuilder )
+
+Unlike most other nodes, lighting nodes do not return a output node in [Node#setup](Node.html#setup). The main purpose of lighting nodes is to configure the current [LightingModel](LightingModel.html) and/or invocate the respective interface methods.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [LightingNode#setup](LightingNode.html#setup)
+
+### .setupDirect( builder : NodeBuilder ) : Object | undefined (abstract)
+
+Sets up the direct lighting for the analytic light node.
+
+**builder**
+
+The builder object used for setting up the light.
+
+**Returns:** The direct light data (color and direction).
+
+### .setupDirectRectArea( builder : NodeBuilder ) : Object | undefined (abstract)
+
+Sets up the direct rect area lighting for the analytic light node.
+
+**builder**
+
+The builder object used for setting up the light.
+
+**Returns:** The direct rect area light data.
+
+### .setupShadow( builder : NodeBuilder )
+
+Setups the shadow for this light. This method is only executed if the light cast shadows and the current build object receives shadows. It incorporates shadows into the lighting computation.
+
+**builder**
+
+The current node builder.
+
+### .setupShadowNode() : ShadowNode
+
+Setups the shadow node for this light. The method exists so concrete light classes can setup different types of shadow nodes.
+
+**Returns:** The created shadow node.
+
+### .update( frame : NodeFrame )
+
+The update method is used to update light uniforms per frame. Potentially overwritten in concrete light nodes to update light specific uniforms.
+
+**frame**
+
+A reference to the current node frame.
+
+**Overrides:** [LightingNode#update](LightingNode.html#update)
+
+## Source
+
+[src/nodes/lighting/AnalyticLightNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/lighting/AnalyticLightNode.js)
\ No newline at end of file
diff --git a/docs/pages/AnamorphicNode.html.md b/docs/pages/AnamorphicNode.html.md
new file mode 100644
index 00000000000000..513c182fd1f7fb
--- /dev/null
+++ b/docs/pages/AnamorphicNode.html.md
@@ -0,0 +1,127 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# AnamorphicNode
+
+Post processing node for adding an anamorphic flare effect.
+
+## Import
+
+AnamorphicNode is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { anamorphic } from 'three/addons/tsl/display/AnamorphicNode.js';
+```
+
+## Constructor
+
+### new AnamorphicNode( textureNode : TextureNode, thresholdNode : Node., scaleNode : Node., samples : number )
+
+Constructs a new anamorphic node.
+
+**textureNode**
+
+The texture node that represents the input of the effect.
+
+**thresholdNode**
+
+The threshold is one option to control the intensity and size of the effect.
+
+**scaleNode**
+
+Defines the vertical scale of the flares.
+
+**samples**
+
+More samples result in larger flares and a more expensive runtime behavior.
+
+## Properties
+
+### .colorNode : Node.
+
+The color of the flares.
+
+### .resolution : Vector2
+
+The resolution scale.
+
+Default is `{(1,1)}`.
+
+**Deprecated:** Yes
+
+### .resolutionScale : number
+
+The resolution scale.
+
+### .samples : Node.
+
+More samples result in larger flares and a more expensive runtime behavior.
+
+### .scaleNode : Node.
+
+Defines the vertical scale of the flares.
+
+### .textureNode : TextureNode
+
+The texture node that represents the input of the effect.
+
+### .thresholdNode : Node.
+
+The threshold is one option to control the intensity and size of the effect.
+
+### .updateBeforeType : string
+
+The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node renders its effect once per frame in `updateBefore()`.
+
+Default is `'frame'`.
+
+**Overrides:** [TempNode#updateBeforeType](TempNode.html#updateBeforeType)
+
+## Methods
+
+### .dispose()
+
+Frees internal resources. This method should be called when the effect is no longer required.
+
+**Overrides:** [TempNode#dispose](TempNode.html#dispose)
+
+### .getTextureNode() : PassTextureNode
+
+Returns the result of the effect as a texture node.
+
+**Returns:** A texture node that represents the result of the effect.
+
+### .setSize( width : number, height : number )
+
+Sets the size of the effect.
+
+**width**
+
+The width of the effect.
+
+**height**
+
+The height of the effect.
+
+### .setup( builder : NodeBuilder ) : PassTextureNode
+
+This method is used to setup the effect's TSL code.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#setup](TempNode.html#setup)
+
+### .updateBefore( frame : NodeFrame )
+
+This method is used to render the effect once per frame.
+
+**frame**
+
+The current node frame.
+
+**Overrides:** [TempNode#updateBefore](TempNode.html#updateBefore)
+
+## Source
+
+[examples/jsm/tsl/display/AnamorphicNode.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/tsl/display/AnamorphicNode.js)
\ No newline at end of file
diff --git a/docs/pages/AnimationAction.html.md b/docs/pages/AnimationAction.html.md
new file mode 100644
index 00000000000000..83a50774142259
--- /dev/null
+++ b/docs/pages/AnimationAction.html.md
@@ -0,0 +1,337 @@
+# AnimationAction
+
+An instance of `AnimationAction` schedules the playback of an animation which is stored in [AnimationClip](AnimationClip.html).
+
+## Constructor
+
+### new AnimationAction( mixer : AnimationMixer, clip : AnimationClip, localRoot : Object3D, blendMode : NormalAnimationBlendMode | AdditiveAnimationBlendMode )
+
+Constructs a new animation action.
+
+**mixer**
+
+The mixer that is controlled by this action.
+
+**clip**
+
+The animation clip that holds the actual keyframes.
+
+**localRoot**
+
+The root object on which this action is performed.
+
+Default is `null`.
+
+**blendMode**
+
+The blend mode.
+
+## Properties
+
+### .blendMode : NormalAnimationBlendMode | AdditiveAnimationBlendMode
+
+Defines how the animation is blended/combined when two or more animations are simultaneously played.
+
+### .clampWhenFinished : boolean
+
+If set to true the animation will automatically be paused on its last frame.
+
+If set to false, [AnimationAction#enabled](AnimationAction.html#enabled) will automatically be switched to `false` when the last loop of the action has finished, so that this action has no further impact.
+
+Note: This member has no impact if the action is interrupted (it has only an effect if its last loop has really finished).
+
+Default is `false`.
+
+### .enabled : boolean
+
+If set to `false`, the action is disabled so it has no impact.
+
+When the action is re-enabled, the animation continues from its current time (setting `enabled` to `false` doesn't reset the action).
+
+Default is `true`.
+
+### .loop : LoopRepeat | LoopOnce | LoopPingPong
+
+The loop mode, set via [AnimationAction#setLoop](AnimationAction.html#setLoop).
+
+Default is `LoopRepeat`.
+
+### .paused : boolean
+
+If set to `true`, the playback of the action is paused.
+
+Default is `false`.
+
+### .repetitions : number
+
+The number of repetitions of the performed clip over the course of this action. Can be set via [AnimationAction#setLoop](AnimationAction.html#setLoop).
+
+Setting this number has no effect if [AnimationAction#loop](AnimationAction.html#loop) is set to `THREE:LoopOnce`.
+
+Default is `Infinity`.
+
+### .time : number
+
+The local time of this action (in seconds, starting with `0`).
+
+The value gets clamped or wrapped to `[0,clip.duration]` (according to the loop state).
+
+Default is `Infinity`.
+
+### .timeScale : number
+
+Scaling factor for the [AnimationAction#time](AnimationAction.html#time). A value of `0` causes the animation to pause. Negative values cause the animation to play backwards.
+
+Default is `1`.
+
+### .weight : number
+
+The degree of influence of this action (in the interval `[0, 1]`). Values between `0` (no impact) and `1` (full impact) can be used to blend between several actions.
+
+Default is `1`.
+
+### .zeroSlopeAtEnd : boolean
+
+Enables smooth interpolation without separate clips for start, loop and end.
+
+Default is `true`.
+
+### .zeroSlopeAtStart : boolean
+
+Enables smooth interpolation without separate clips for start, loop and end.
+
+Default is `true`.
+
+## Methods
+
+### .crossFadeFrom( fadeOutAction : AnimationAction, duration : number, warp : boolean ) : AnimationAction
+
+Causes this action to fade in and the given action to fade out, within the passed time interval.
+
+**fadeOutAction**
+
+The animation action to fade out.
+
+**duration**
+
+The duration of the fade.
+
+**warp**
+
+Whether warping should be used or not.
+
+Default is `false`.
+
+**Returns:** A reference to this animation action.
+
+### .crossFadeTo( fadeInAction : AnimationAction, duration : number, warp : boolean ) : AnimationAction
+
+Causes this action to fade out and the given action to fade in, within the passed time interval.
+
+**fadeInAction**
+
+The animation action to fade in.
+
+**duration**
+
+The duration of the fade.
+
+**warp**
+
+Whether warping should be used or not.
+
+Default is `false`.
+
+**Returns:** A reference to this animation action.
+
+### .fadeIn( duration : number ) : AnimationAction
+
+Fades the animation in by increasing its weight gradually from `0` to `1`, within the passed time interval.
+
+**duration**
+
+The duration of the fade.
+
+**Returns:** A reference to this animation action.
+
+### .fadeOut( duration : number ) : AnimationAction
+
+Fades the animation out by decreasing its weight gradually from `1` to `0`, within the passed time interval.
+
+**duration**
+
+The duration of the fade.
+
+**Returns:** A reference to this animation action.
+
+### .getClip() : AnimationClip
+
+Returns the animation clip of this animation action.
+
+**Returns:** The animation clip.
+
+### .getEffectiveTimeScale() : number
+
+Returns the effective time scale of this action.
+
+**Returns:** The effective time scale.
+
+### .getEffectiveWeight() : number
+
+Returns the effective weight of this action.
+
+**Returns:** The effective weight.
+
+### .getMixer() : AnimationMixer
+
+Returns the animation mixer of this animation action.
+
+**Returns:** The animation mixer.
+
+### .getRoot() : Object3D
+
+Returns the root object of this animation action.
+
+**Returns:** The root object.
+
+### .halt( duration : number ) : AnimationAction
+
+Decelerates this animation's speed to `0` within the passed time interval.
+
+**duration**
+
+The duration.
+
+**Returns:** A reference to this animation action.
+
+### .isRunning() : boolean
+
+Returns `true` if the animation is running.
+
+**Returns:** Whether the animation is running or not.
+
+### .isScheduled() : boolean
+
+Returns `true` when [AnimationAction#play](AnimationAction.html#play) has been called.
+
+**Returns:** Whether the animation is scheduled or not.
+
+### .play() : AnimationAction
+
+Starts the playback of the animation.
+
+**Returns:** A reference to this animation action.
+
+### .reset() : AnimationAction
+
+Resets the playback of the animation.
+
+**Returns:** A reference to this animation action.
+
+### .setDuration( duration : number ) : AnimationAction
+
+Sets the duration for a single loop of this action.
+
+**duration**
+
+The duration to set.
+
+**Returns:** A reference to this animation action.
+
+### .setEffectiveTimeScale( timeScale : number ) : AnimationAction
+
+Sets the effective time scale of this action.
+
+An action has no effect and thus an effective time scale of zero when the action is paused.
+
+**timeScale**
+
+The time scale to set.
+
+**Returns:** A reference to this animation action.
+
+### .setEffectiveWeight( weight : number ) : AnimationAction
+
+Sets the effective weight of this action.
+
+An action has no effect and thus an effective weight of zero when the action is disabled.
+
+**weight**
+
+The weight to set.
+
+**Returns:** A reference to this animation action.
+
+### .setLoop( mode : LoopRepeat | LoopOnce | LoopPingPong, repetitions : number ) : AnimationAction
+
+Configures the loop settings for this action.
+
+**mode**
+
+The loop mode.
+
+**repetitions**
+
+The number of repetitions.
+
+**Returns:** A reference to this animation action.
+
+### .startAt( time : number ) : AnimationAction
+
+Defines the time when the animation should start.
+
+**time**
+
+The start time in seconds.
+
+**Returns:** A reference to this animation action.
+
+### .stop() : AnimationAction
+
+Stops the playback of the animation.
+
+**Returns:** A reference to this animation action.
+
+### .stopFading() : AnimationAction
+
+Stops any fading which is applied to this action.
+
+**Returns:** A reference to this animation action.
+
+### .stopWarping() : AnimationAction
+
+Stops any scheduled warping which is applied to this action.
+
+**Returns:** A reference to this animation action.
+
+### .syncWith( action : AnimationAction ) : AnimationAction
+
+Synchronizes this action with the passed other action.
+
+**action**
+
+The action to sync with.
+
+**Returns:** A reference to this animation action.
+
+### .warp( startTimeScale : number, endTimeScale : number, duration : number ) : AnimationAction
+
+Changes the playback speed, within the passed time interval, by modifying [AnimationAction#timeScale](AnimationAction.html#timeScale) gradually from `startTimeScale` to `endTimeScale`.
+
+**startTimeScale**
+
+The start time scale.
+
+**endTimeScale**
+
+The end time scale.
+
+**duration**
+
+The duration.
+
+**Returns:** A reference to this animation action.
+
+## Source
+
+[src/animation/AnimationAction.js](https://github.com/mrdoob/three.js/blob/master/src/animation/AnimationAction.js)
\ No newline at end of file
diff --git a/docs/pages/AnimationClip.html.md b/docs/pages/AnimationClip.html.md
new file mode 100644
index 00000000000000..f95aa02dc4b65e
--- /dev/null
+++ b/docs/pages/AnimationClip.html.md
@@ -0,0 +1,197 @@
+# AnimationClip
+
+A reusable set of keyframe tracks which represent an animation.
+
+## Constructor
+
+### new AnimationClip( name : string, duration : number, tracks : Array., blendMode : NormalAnimationBlendMode | AdditiveAnimationBlendMode )
+
+Constructs a new animation clip.
+
+Note: Instead of instantiating an AnimationClip directly with the constructor, you can use the static interface of this class for creating clips. In most cases though, animation clips will automatically be created by loaders when importing animated 3D assets.
+
+**name**
+
+The clip's name.
+
+Default is `''`.
+
+**duration**
+
+The clip's duration in seconds. If a negative value is passed, the duration will be calculated from the passed keyframes.
+
+Default is `-1`.
+
+**tracks**
+
+An array of keyframe tracks.
+
+**blendMode**
+
+Defines how the animation is blended/combined when two or more animations are simultaneously played.
+
+Default is `NormalAnimationBlendMode`.
+
+## Properties
+
+### .blendMode : NormalAnimationBlendMode | AdditiveAnimationBlendMode
+
+Defines how the animation is blended/combined when two or more animations are simultaneously played.
+
+### .duration : number
+
+The clip's duration in seconds.
+
+### .name : string
+
+The clip's name.
+
+### .tracks : Array.
+
+An array of keyframe tracks.
+
+### .userData : Object
+
+An object that can be used to store custom data about the animation clip. It should not hold references to functions as these will not be cloned.
+
+### .uuid : string (readonly)
+
+The UUID of the animation clip.
+
+## Methods
+
+### .clone() : AnimationClip
+
+Returns a new animation clip with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .optimize() : AnimationClip
+
+Optimizes each track by removing equivalent sequential keys (which are common in morph target sequences).
+
+**Returns:** A reference to this animation clip.
+
+### .resetDuration() : AnimationClip
+
+Sets the duration of this clip to the duration of its longest keyframe track.
+
+**Returns:** A reference to this animation clip.
+
+### .toJSON() : Object
+
+Serializes this animation clip into JSON.
+
+**Returns:** The JSON object.
+
+### .trim() : AnimationClip
+
+Trims all tracks to the clip's duration.
+
+**Returns:** A reference to this animation clip.
+
+### .validate() : boolean
+
+Performs minimal validation on each track in the clip. Returns `true` if all tracks are valid.
+
+**Returns:** Whether the clip's keyframes are valid or not.
+
+## Static Methods
+
+### .CreateClipsFromMorphTargetSequences( morphTargets : Array., fps : number, noLoop : boolean ) : Array.
+
+Returns an array of new AnimationClips created from the morph target sequences of a geometry, trying to sort morph target names into animation-group-based patterns like "Walk\_001, Walk\_002, Run\_001, Run\_002...".
+
+See [MD2Loader#parse](MD2Loader.html#parse) as an example for how the method should be used.
+
+**morphTargets**
+
+A sequence of morph targets.
+
+**fps**
+
+The Frames-Per-Second value.
+
+**noLoop**
+
+Whether the clip should be no loop or not.
+
+**Returns:** An array of new animation clips.
+
+### .CreateFromMorphTargetSequence( name : string, morphTargetSequence : Array., fps : number, noLoop : boolean ) : AnimationClip
+
+Returns a new animation clip from the passed morph targets array of a geometry, taking a name and the number of frames per second.
+
+Note: The fps parameter is required, but the animation speed can be overridden via [AnimationAction#setDuration](AnimationAction.html#setDuration).
+
+**name**
+
+The name of the animation clip.
+
+**morphTargetSequence**
+
+A sequence of morph targets.
+
+**fps**
+
+The Frames-Per-Second value.
+
+**noLoop**
+
+Whether the clip should be no loop or not.
+
+**Returns:** The new animation clip.
+
+### .findByName( objectOrClipArray : Array. | Object3D, name : string ) : AnimationClip
+
+Searches for an animation clip by name, taking as its first parameter either an array of clips, or a mesh or geometry that contains an array named "animations" property.
+
+**objectOrClipArray**
+
+The array or object to search through.
+
+**name**
+
+The name to search for.
+
+**Returns:** The found animation clip. Returns `null` if no clip has been found.
+
+### .parse( json : Object ) : AnimationClip
+
+Factory method for creating an animation clip from the given JSON.
+
+**json**
+
+The serialized animation clip.
+
+**Returns:** The new animation clip.
+
+### .parseAnimation( animation : Object, bones : Array. ) : AnimationClip
+
+Parses the `animation.hierarchy` format and returns a new animation clip.
+
+**animation**
+
+A serialized animation clip as JSON.
+
+**bones**
+
+An array of bones.
+
+**Deprecated:** since r175.
+
+**Returns:** The new animation clip.
+
+### .toJSON( clip : AnimationClip ) : Object
+
+Serializes the given animation clip into JSON.
+
+**clip**
+
+The animation clip to serialize.
+
+**Returns:** The JSON object.
+
+## Source
+
+[src/animation/AnimationClip.js](https://github.com/mrdoob/three.js/blob/master/src/animation/AnimationClip.js)
\ No newline at end of file
diff --git a/docs/pages/AnimationClipCreator.html.md b/docs/pages/AnimationClipCreator.html.md
new file mode 100644
index 00000000000000..eed1f2d02198a4
--- /dev/null
+++ b/docs/pages/AnimationClipCreator.html.md
@@ -0,0 +1,101 @@
+# AnimationClipCreator
+
+A utility class with factory methods for creating basic animation clips.
+
+## Import
+
+AnimationClipCreator is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { AnimationClipCreator } from 'three/addons/animation/AnimationClipCreator.js';
+```
+
+## Static Methods
+
+### .CreateMaterialColorAnimation( duration : number, colors : Array. ) : AnimationClip
+
+Creates an animation clip that animates the `color` property of a 3D object's material.
+
+**duration**
+
+The duration of the animation.
+
+**colors**
+
+An array of colors that should be sequentially animated.
+
+**Returns:** The created animation clip.
+
+### .CreatePulsationAnimation( duration : number, pulseScale : number ) : AnimationClip
+
+Creates an animation clip that scales a 3D object in a pulse pattern in the given period.
+
+**duration**
+
+The duration of the animation.
+
+**pulseScale**
+
+The scale of the pulse.
+
+**Returns:** The created animation clip.
+
+### .CreateRotationAnimation( period : number, axis : 'x' | 'y' | 'z' ) : AnimationClip
+
+Creates an animation clip that rotates a 3D object 360 degrees in the given period of time around the given axis.
+
+**period**
+
+The duration of the animation.
+
+**axis**
+
+The axis of rotation.
+
+Default is `'x'`.
+
+**Returns:** The created animation clip.
+
+### .CreateScaleAxisAnimation( period : number, axis : 'x' | 'y' | 'z' ) : AnimationClip
+
+Creates an animation clip that scales a 3D object from `0` to `1` in the given period of time along the given axis.
+
+**period**
+
+The duration of the animation.
+
+**axis**
+
+The axis to scale the 3D object along.
+
+Default is `'x'`.
+
+**Returns:** The created animation clip.
+
+### .CreateShakeAnimation( duration : number, shakeScale : Vector3 ) : AnimationClip
+
+Creates an animation clip that translates a 3D object in a shake pattern in the given period.
+
+**duration**
+
+The duration of the animation.
+
+**shakeScale**
+
+The scale of the shake.
+
+**Returns:** The created animation clip.
+
+### .CreateVisibilityAnimation( duration : number ) : AnimationClip
+
+Creates an animation clip that toggles the visibility of a 3D object.
+
+**duration**
+
+The duration of the animation.
+
+**Returns:** The created animation clip.
+
+## Source
+
+[examples/jsm/animation/AnimationClipCreator.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/animation/AnimationClipCreator.js)
\ No newline at end of file
diff --git a/docs/pages/AnimationLoader.html.md b/docs/pages/AnimationLoader.html.md
new file mode 100644
index 00000000000000..a6db992ab18801
--- /dev/null
+++ b/docs/pages/AnimationLoader.html.md
@@ -0,0 +1,62 @@
+*Inheritance: Loader →*
+
+# AnimationLoader
+
+Class for loading animation clips in the JSON format. The files are internally loaded via [FileLoader](FileLoader.html).
+
+## Code Example
+
+```js
+const loader = new THREE.AnimationLoader();
+const animations = await loader.loadAsync( 'animations/animation.js' );
+```
+
+## Constructor
+
+### new AnimationLoader( manager : LoadingManager )
+
+Constructs a new animation loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and pass the loaded animations as an array holding instances of [AnimationClip](AnimationClip.html) to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( json : Object ) : Array.
+
+Parses the given JSON object and returns an array of animation clips.
+
+**json**
+
+The serialized animation clips.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** The parsed animation clips.
+
+## Source
+
+[src/loaders/AnimationLoader.js](https://github.com/mrdoob/three.js/blob/master/src/loaders/AnimationLoader.js)
\ No newline at end of file
diff --git a/docs/pages/AnimationMixer.html.md b/docs/pages/AnimationMixer.html.md
new file mode 100644
index 00000000000000..6b1f379c05a79a
--- /dev/null
+++ b/docs/pages/AnimationMixer.html.md
@@ -0,0 +1,133 @@
+# AnimationMixer
+
+`AnimationMixer` is a player for animations on a particular object in the scene. When multiple objects in the scene are animated independently, one `AnimationMixer` may be used for each object.
+
+## Constructor
+
+### new AnimationMixer( root : Object3D )
+
+Constructs a new animation mixer.
+
+**root**
+
+The object whose animations shall be played by this mixer.
+
+## Properties
+
+### .time : number
+
+The global mixer time (in seconds; starting with `0` on the mixer's creation).
+
+Default is `0`.
+
+### .timeScale : number
+
+A scaling factor for the global time.
+
+Note: Setting this member to `0` and later back to `1` is a possibility to pause/unpause all actions that are controlled by this mixer.
+
+Default is `1`.
+
+## Methods
+
+### .clipAction( clip : AnimationClip | string, optionalRoot : Object3D, blendMode : NormalAnimationBlendMode | AdditiveAnimationBlendMode ) : AnimationAction
+
+Returns an instance of [AnimationAction](AnimationAction.html) for the passed clip.
+
+If an action fitting the clip and root parameters doesn't yet exist, it will be created by this method. Calling this method several times with the same clip and root parameters always returns the same action.
+
+**clip**
+
+An animation clip or alternatively the name of the animation clip.
+
+**optionalRoot**
+
+An alternative root object.
+
+**blendMode**
+
+The blend mode.
+
+**Returns:** The animation action.
+
+### .existingAction( clip : AnimationClip | string, optionalRoot : Object3D ) : AnimationAction
+
+Returns an existing animation action for the passed clip.
+
+**clip**
+
+An animation clip or alternatively the name of the animation clip.
+
+**optionalRoot**
+
+An alternative root object.
+
+**Returns:** The animation action. Returns `null` if no action was found.
+
+### .getRoot() : Object3D
+
+Returns this mixer's root object.
+
+**Returns:** The mixer's root object.
+
+### .setTime( time : number ) : AnimationMixer
+
+Sets the global mixer to a specific time and updates the animation accordingly.
+
+This is useful when you need to jump to an exact time in an animation. The input parameter will be scaled by [AnimationMixer#timeScale](AnimationMixer.html#timeScale)
+
+**time**
+
+The time to set in seconds.
+
+**Returns:** A reference to this animation mixer.
+
+### .stopAllAction() : AnimationMixer
+
+Deactivates all previously scheduled actions on this mixer.
+
+**Returns:** A reference to this animation mixer.
+
+### .uncacheAction( clip : AnimationClip | string, optionalRoot : Object3D )
+
+Deallocates all memory resources for an action. The action is identified by the given clip and an optional root object. Before using this method make sure to call [AnimationAction#stop](AnimationAction.html#stop) to deactivate the action.
+
+**clip**
+
+An animation clip or alternatively the name of the animation clip.
+
+**optionalRoot**
+
+An alternative root object.
+
+### .uncacheClip( clip : AnimationClip )
+
+Deallocates all memory resources for a clip. Before using this method make sure to call [AnimationAction#stop](AnimationAction.html#stop) for all related actions.
+
+**clip**
+
+The clip to uncache.
+
+### .uncacheRoot( root : Object3D )
+
+Deallocates all memory resources for a root object. Before using this method make sure to call [AnimationAction#stop](AnimationAction.html#stop) for all related actions or alternatively [AnimationMixer#stopAllAction](AnimationMixer.html#stopAllAction) when the mixer operates on a single root.
+
+**root**
+
+The root object to uncache.
+
+### .update( deltaTime : number ) : AnimationMixer
+
+Advances the global mixer time and updates the animation.
+
+This is usually done in the render loop by passing the delta time from [Clock](Clock.html) or [Timer](Timer.html).
+
+**deltaTime**
+
+The delta time in seconds.
+
+**Returns:** A reference to this animation mixer.
+
+## Source
+
+[src/animation/AnimationMixer.js](https://github.com/mrdoob/three.js/blob/master/src/animation/AnimationMixer.js)
\ No newline at end of file
diff --git a/docs/pages/AnimationObjectGroup.html.md b/docs/pages/AnimationObjectGroup.html.md
new file mode 100644
index 00000000000000..eb09d74248bfa2
--- /dev/null
+++ b/docs/pages/AnimationObjectGroup.html.md
@@ -0,0 +1,70 @@
+# AnimationObjectGroup
+
+A group of objects that receives a shared animation state.
+
+Usage:
+
+* Add objects you would otherwise pass as 'root' to the constructor or the .clipAction method of AnimationMixer.
+* Instead pass this object as 'root'.
+* You can also add and remove objects later when the mixer is running.
+
+Note:
+
+* Objects of this class appear as one object to the mixer, so cache control of the individual objects must be done on the group.
+
+Limitation:
+
+* The animated properties must be compatible among the all objects in the group.
+* A single property can either be controlled through a target group or directly, but not both.
+
+## Constructor
+
+### new AnimationObjectGroup( …arguments : Object3D )
+
+Constructs a new animation group.
+
+**arguments**
+
+An arbitrary number of 3D objects that share the same animation state.
+
+## Properties
+
+### .isAnimationObjectGroup : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .uuid : string (readonly)
+
+The UUID of the 3D object.
+
+## Methods
+
+### .add( …arguments : Object3D )
+
+Adds an arbitrary number of objects to this animation group.
+
+**arguments**
+
+The 3D objects to add.
+
+### .remove( …arguments : Object3D )
+
+Removes an arbitrary number of objects to this animation group
+
+**arguments**
+
+The 3D objects to remove.
+
+### .uncache( …arguments : Object3D )
+
+Deallocates all memory resources for the passed 3D objects of this animation group.
+
+**arguments**
+
+The 3D objects to uncache.
+
+## Source
+
+[src/animation/AnimationObjectGroup.js](https://github.com/mrdoob/three.js/blob/master/src/animation/AnimationObjectGroup.js)
\ No newline at end of file
diff --git a/docs/pages/AnimationUtils.html.md b/docs/pages/AnimationUtils.html.md
new file mode 100644
index 00000000000000..8566fbf7a36807
--- /dev/null
+++ b/docs/pages/AnimationUtils.html.md
@@ -0,0 +1,137 @@
+# AnimationUtils
+
+A class with various methods to assist with animations.
+
+## Static Methods
+
+### .convertArray( array : TypedArray | Array, type : TypedArray.constructor ) : TypedArray
+
+Converts an array to a specific type
+
+**array**
+
+The array to convert.
+
+**type**
+
+The constructor of a type array.
+
+**Returns:** The converted array
+
+### .flattenJSON( jsonKeys : Array., times : Array., values : Array., valuePropertyName : string )
+
+Used for parsing AOS keyframe formats.
+
+**jsonKeys**
+
+A list of JSON keyframes.
+
+**times**
+
+This array will be filled with keyframe times by this method.
+
+**values**
+
+This array will be filled with keyframe values by this method.
+
+**valuePropertyName**
+
+The name of the property to use.
+
+### .getKeyframeOrder( times : Array. ) : Array.
+
+Returns an array by which times and values can be sorted.
+
+**times**
+
+The keyframe time values.
+
+**Returns:** The array.
+
+### .isTypedArray( object : any ) : boolean
+
+Returns `true` if the given object is a typed array.
+
+**object**
+
+The object to check.
+
+**Returns:** Whether the given object is a typed array.
+
+### .makeClipAdditive( targetClip : AnimationClip, referenceFrame : number, referenceClip : AnimationClip, fps : number ) : AnimationClip
+
+Converts the keyframes of the given animation clip to an additive format.
+
+**targetClip**
+
+The clip to make additive.
+
+**referenceFrame**
+
+The reference frame.
+
+Default is `0`.
+
+**referenceClip**
+
+The reference clip.
+
+Default is `targetClip`.
+
+**fps**
+
+The FPS.
+
+Default is `30`.
+
+**Returns:** The updated clip which is now additive.
+
+### .sortedArray( values : Array., stride : number, order : Array. ) : Array.
+
+Sorts the given array by the previously computed order via `getKeyframeOrder()`.
+
+**values**
+
+The values to sort.
+
+**stride**
+
+The stride.
+
+**order**
+
+The sort order.
+
+**Returns:** The sorted values.
+
+### .subclip( sourceClip : AnimationClip, name : string, startFrame : number, endFrame : number, fps : number ) : AnimationClip
+
+Creates a new clip, containing only the segment of the original clip between the given frames.
+
+**sourceClip**
+
+The values to sort.
+
+**name**
+
+The name of the clip.
+
+**startFrame**
+
+The start frame.
+
+**endFrame**
+
+The end frame.
+
+**fps**
+
+The FPS.
+
+Default is `30`.
+
+**Returns:** The new sub clip.
+
+## Source
+
+[src/animation/AnimationUtils.js](https://github.com/mrdoob/three.js/blob/master/src/animation/AnimationUtils.js)
\ No newline at end of file
diff --git a/docs/pages/ArcCurve.html.md b/docs/pages/ArcCurve.html.md
new file mode 100644
index 00000000000000..c43979bfa9e24a
--- /dev/null
+++ b/docs/pages/ArcCurve.html.md
@@ -0,0 +1,59 @@
+*Inheritance: Curve → EllipseCurve →*
+
+# ArcCurve
+
+A curve representing an arc.
+
+## Constructor
+
+### new ArcCurve( aX : number, aY : number, aRadius : number, aStartAngle : number, aEndAngle : number, aClockwise : boolean )
+
+Constructs a new arc curve.
+
+**aX**
+
+The X center of the ellipse.
+
+Default is `0`.
+
+**aY**
+
+The Y center of the ellipse.
+
+Default is `0`.
+
+**aRadius**
+
+The radius of the ellipse in the x direction.
+
+Default is `1`.
+
+**aStartAngle**
+
+The start angle of the curve in radians starting from the positive X axis.
+
+Default is `0`.
+
+**aEndAngle**
+
+The end angle of the curve in radians starting from the positive X axis.
+
+Default is `Math.PI*2`.
+
+**aClockwise**
+
+Whether the ellipse is drawn clockwise or not.
+
+Default is `false`.
+
+## Properties
+
+### .isArcCurve : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/extras/curves/ArcCurve.js](https://github.com/mrdoob/three.js/blob/master/src/extras/curves/ArcCurve.js)
\ No newline at end of file
diff --git a/docs/pages/ArcballControls.html.md b/docs/pages/ArcballControls.html.md
new file mode 100644
index 00000000000000..56a46bb7d8b956
--- /dev/null
+++ b/docs/pages/ArcballControls.html.md
@@ -0,0 +1,307 @@
+*Inheritance: EventDispatcher → Controls →*
+
+# ArcballControls
+
+Arcball controls allow the camera to be controlled by a virtual trackball with full touch support and advanced navigation functionality. Cursor/finger positions and movements are mapped over a virtual trackball surface represented by a gizmo and mapped in intuitive and consistent camera movements. Dragging cursor/fingers will cause camera to orbit around the center of the trackball in a conservative way (returning to the starting point will make the camera return to its starting orientation).
+
+In addition to supporting pan, zoom and pinch gestures, Arcball controls provide focus< functionality with a double click/tap for intuitively moving the object's point of interest in the center of the virtual trackball. Focus allows a much better inspection and navigation in complex environment. Moreover Arcball controls allow FOV manipulation (in a vertigo-style method) and z-rotation. Saving and restoring of Camera State is supported also through clipboard (use ctrl+c and ctrl+v shortcuts for copy and paste the state).
+
+Unlike [OrbitControls](OrbitControls.html) and [TrackballControls](TrackballControls.html), `ArcballControls` doesn't require `update()` to be called externally in an animation loop when animations are on.
+
+## Import
+
+ArcballControls is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { ArcballControls } from 'three/addons/controls/ArcballControls.js';
+```
+
+## Constructor
+
+### new ArcballControls( camera : Camera, domElement : HTMLElement, scene : Scene )
+
+Constructs a new controls instance.
+
+**camera**
+
+The camera to be controlled. The camera must not be a child of another object, unless that object is the scene itself.
+
+**domElement**
+
+The HTML element used for event listeners.
+
+Default is `null`.
+
+**scene**
+
+The scene rendered by the camera. If not given, gizmos cannot be shown.
+
+Default is `null`.
+
+## Properties
+
+### .adjustNearFar : boolean
+
+If set to `true`, the camera's near and far values will be adjusted every time zoom is performed trying to maintain the same visible portion given by initial near and far values. Only works with perspective cameras.
+
+Default is `false`.
+
+### .cursorZoom : boolean
+
+Set to `true` to make zoom become cursor centered.
+
+Default is `false`.
+
+### .dampingFactor : number
+
+The damping inertia used if 'enableAnimations`is set to`true\`.
+
+Default is `25`.
+
+### .enableAnimations : boolean
+
+Set to `true` to enable animations for rotation (damping) and focus operation.
+
+Default is `true`.
+
+### .enableFocus : boolean
+
+Enable or disable camera focusing on double-tap (or click) operations.
+
+Default is `true`.
+
+### .enableGizmos : boolean
+
+Enable or disable gizmos.
+
+Default is `true`.
+
+### .enableGrid : boolean
+
+If set to `true`, a grid will appear when panning operation is being performed (desktop interaction only).
+
+Default is `false`.
+
+### .enablePan : boolean
+
+Enable or disable camera panning.
+
+Default is `true`.
+
+### .enableRotate : boolean
+
+Enable or disable camera rotation.
+
+Default is `true`.
+
+### .enableZoom : boolean
+
+Enable or disable camera zoom.
+
+Default is `true`.
+
+### .focusAnimationTime : number
+
+Duration of focus animations in ms.
+
+Default is `500`.
+
+### .maxDistance : number
+
+How far you can dolly out. For perspective cameras only.
+
+Default is `Infinity`.
+
+### .maxFov : number
+
+The maximum FOV in degrees.
+
+Default is `90`.
+
+### .maxZoom : number
+
+How far you can zoom out. For orthographic cameras only.
+
+Default is `Infinity`.
+
+### .minDistance : number
+
+How far you can dolly in. For perspective cameras only.
+
+Default is `0`.
+
+### .minFov : number
+
+The minimum FOV in degrees.
+
+Default is `5`.
+
+### .minZoom : number
+
+How far you can zoom in. For orthographic cameras only.
+
+Default is `0`.
+
+### .mouseActions : Array.
+
+Holds the mouse actions of this controls. This property is maintained by the methods `setMouseAction()` and `unsetMouseAction()`.
+
+### .radiusFactor : number
+
+The size of the gizmo relative to the screen width and height.
+
+Default is `0.67`.
+
+### .rotateSpeed : number
+
+Speed of rotation.
+
+Default is `1`.
+
+### .scaleFactor : number
+
+The scaling factor used when performing zoom operation.
+
+Default is `1.1`.
+
+### .scene : Scene
+
+The scene rendered by the camera. If not given, gizmos cannot be shown.
+
+Default is `null`.
+
+### .target : Vector3
+
+The control's focus point.
+
+### .wMax : number
+
+Maximum angular velocity allowed on rotation animation start.
+
+Default is `20`.
+
+## Methods
+
+### .activateGizmos( isActive : boolean )
+
+Makes rotation gizmos more or less visible.
+
+**isActive**
+
+If set to `true`, gizmos are more visible.
+
+### .copyState()
+
+Copy the current state to clipboard (as a readable JSON text).
+
+### .disposeGrid()
+
+Removes the grid from the scene.
+
+### .getRaycaster() : Raycaster
+
+Returns the raycaster that is used for user interaction. This object is shared between all instances of `ArcballControls`.
+
+**Returns:** The internal raycaster.
+
+### .pasteState()
+
+Set the controls state from the clipboard, assumes that the clipboard stores a JSON text as saved from `copyState()`.
+
+### .reset()
+
+Resets the controls.
+
+### .saveState()
+
+Saves the current state of the control. This can later be recover with `reset()`.
+
+### .setCamera( camera : Camera )
+
+Sets the camera to be controlled. Must be called in order to set a new camera to be controlled.
+
+**camera**
+
+The camera to be controlled.
+
+### .setGizmosVisible( value : boolean )
+
+Sets gizmos visibility.
+
+**value**
+
+Value of gizmos visibility.
+
+### .setMouseAction( operation : 'PAN' | 'ROTATE' | 'ZOOM' | 'FOV', mouse : 0 | 1 | 2 | 'WHEEL', key : 'CTRL' | 'SHIFT' ) : boolean
+
+Set a new mouse action by specifying the operation to be performed and a mouse/key combination. In case of conflict, replaces the existing one.
+
+**operation**
+
+The operation to be performed ('PAN', 'ROTATE', 'ZOOM', 'FOV').
+
+**mouse**
+
+A mouse button (0, 1, 2) or 'WHEEL' for wheel notches.
+
+**key**
+
+The keyboard modifier ('CTRL', 'SHIFT') or null if key is not needed.
+
+Default is `null`.
+
+**Returns:** `true` if the mouse action has been successfully added, `false` otherwise.
+
+### .setTbRadius( value : number )
+
+Sets gizmos radius factor and redraws gizmos.
+
+**value**
+
+Value of radius factor.
+
+### .unsetMouseAction( mouse : 0 | 1 | 2 | 'WHEEL', key : 'CTRL' | 'SHIFT' ) : boolean
+
+Remove a mouse action by specifying its mouse/key combination.
+
+**mouse**
+
+A mouse button (0, 1, 2) or 'WHEEL' for wheel notches.
+
+**key**
+
+The keyboard modifier ('CTRL', 'SHIFT') or null if key is not needed.
+
+Default is `null`.
+
+**Returns:** `true` if the operation has been successfully removed, `false` otherwise.
+
+## Events
+
+### .change
+
+Fires when the camera has been transformed by the controls.
+
+##### Type:
+
+* Object
+
+### .end
+
+Fires when an interaction has finished.
+
+##### Type:
+
+* Object
+
+### .start
+
+Fires when an interaction was initiated.
+
+##### Type:
+
+* Object
+
+## Source
+
+[examples/jsm/controls/ArcballControls.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/controls/ArcballControls.js)
\ No newline at end of file
diff --git a/docs/pages/ArrayCamera.html.md b/docs/pages/ArrayCamera.html.md
new file mode 100644
index 00000000000000..f86b115a2d3215
--- /dev/null
+++ b/docs/pages/ArrayCamera.html.md
@@ -0,0 +1,41 @@
+*Inheritance: EventDispatcher → Object3D → Camera → PerspectiveCamera →*
+
+# ArrayCamera
+
+This type of camera can be used in order to efficiently render a scene with a predefined set of cameras. This is an important performance aspect for rendering VR scenes.
+
+An instance of `ArrayCamera` always has an array of sub cameras. It's mandatory to define for each sub camera the `viewport` property which determines the part of the viewport that is rendered with this camera.
+
+## Constructor
+
+### new ArrayCamera( array : Array. )
+
+Constructs a new array camera.
+
+**array**
+
+An array of perspective sub cameras.
+
+Default is `[]`.
+
+## Properties
+
+### .cameras : Array.
+
+An array of perspective sub cameras.
+
+### .isArrayCamera : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .isMultiViewCamera : boolean (readonly)
+
+Whether this camera is used with multiview rendering or not.
+
+Default is `false`.
+
+## Source
+
+[src/cameras/ArrayCamera.js](https://github.com/mrdoob/three.js/blob/master/src/cameras/ArrayCamera.js)
\ No newline at end of file
diff --git a/docs/pages/ArrayElementNode.html.md b/docs/pages/ArrayElementNode.html.md
new file mode 100644
index 00000000000000..5fd7f290784b25
--- /dev/null
+++ b/docs/pages/ArrayElementNode.html.md
@@ -0,0 +1,69 @@
+*Inheritance: EventDispatcher → Node →*
+
+# ArrayElementNode
+
+Base class for representing element access on an array-like node data structures.
+
+## Constructor
+
+### new ArrayElementNode( node : Node, indexNode : Node )
+
+Constructs an array element node.
+
+**node**
+
+The array-like node.
+
+**indexNode**
+
+The index node that defines the element access.
+
+## Properties
+
+### .indexNode : Node
+
+The index node that defines the element access.
+
+### .isArrayElementNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .node : Node
+
+The array-like node.
+
+## Methods
+
+### .getMemberType( builder : NodeBuilder, name : string ) : string
+
+This method is overwritten since the member type is inferred from the array-like node.
+
+**builder**
+
+The current node builder.
+
+**name**
+
+The member name.
+
+**Overrides:** [Node#getMemberType](Node.html#getMemberType)
+
+**Returns:** The member type.
+
+### .getNodeType( builder : NodeBuilder ) : string
+
+This method is overwritten since the node type is inferred from the array-like node.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [Node#getNodeType](Node.html#getNodeType)
+
+**Returns:** The node type.
+
+## Source
+
+[src/nodes/utils/ArrayElementNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/utils/ArrayElementNode.js)
\ No newline at end of file
diff --git a/docs/pages/ArrayNode.html.md b/docs/pages/ArrayNode.html.md
new file mode 100644
index 00000000000000..e4514d0765ae36
--- /dev/null
+++ b/docs/pages/ArrayNode.html.md
@@ -0,0 +1,122 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# ArrayNode
+
+ArrayNode represents a collection of nodes, typically created using the [array](TSL.html#array) function.
+
+## Code Example
+
+```js
+const colors = array( [
+ vec3( 1, 0, 0 ),
+ vec3( 0, 1, 0 ),
+ vec3( 0, 0, 1 )
+] );
+const redColor = tintColors.element( 0 );
+```
+
+## Constructor
+
+### new ArrayNode( nodeType : string, count : number, values : Array. )
+
+Constructs a new array node.
+
+**nodeType**
+
+The data type of the elements.
+
+**count**
+
+Size of the array.
+
+**values**
+
+Array default values.
+
+Default is `null`.
+
+## Properties
+
+### .count : number
+
+Array size.
+
+### .isArrayNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .values : Array.
+
+Array default values.
+
+## Methods
+
+### .generate( builder : NodeBuilder ) : string
+
+This method builds the output node and returns the resulting array as a shader string.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#generate](TempNode.html#generate)
+
+**Returns:** The generated shader string.
+
+### .getArrayCount( builder : NodeBuilder ) : number
+
+Returns the number of elements in the node array.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#getArrayCount](TempNode.html#getArrayCount)
+
+**Returns:** The number of elements in the node array.
+
+### .getElementType( builder : NodeBuilder ) : string
+
+Returns the node's type.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#getElementType](TempNode.html#getElementType)
+
+**Returns:** The type of the node.
+
+### .getMemberType( builder : NodeBuilder, name : string ) : string
+
+Returns the type of a member variable.
+
+**builder**
+
+The current node builder.
+
+**name**
+
+The name of the member variable.
+
+**Overrides:** [TempNode#getMemberType](TempNode.html#getMemberType)
+
+**Returns:** The type of the member variable.
+
+### .getNodeType( builder : NodeBuilder ) : string
+
+Returns the node's type.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#getNodeType](TempNode.html#getNodeType)
+
+**Returns:** The type of the node.
+
+## Source
+
+[src/nodes/core/ArrayNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/core/ArrayNode.js)
\ No newline at end of file
diff --git a/docs/pages/ArrowHelper.html.md b/docs/pages/ArrowHelper.html.md
new file mode 100644
index 00000000000000..6511dc4f224377
--- /dev/null
+++ b/docs/pages/ArrowHelper.html.md
@@ -0,0 +1,116 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# ArrowHelper
+
+An 3D arrow object for visualizing directions.
+
+## Code Example
+
+```js
+const dir = new THREE.Vector3( 1, 2, 0 );
+//normalize the direction vector (convert to vector of length 1)
+dir.normalize();
+const origin = new THREE.Vector3( 0, 0, 0 );
+const length = 1;
+const hex = 0xffff00;
+const arrowHelper = new THREE.ArrowHelper( dir, origin, length, hex );
+scene.add( arrowHelper );
+```
+
+## Constructor
+
+### new ArrowHelper( dir : Vector3, origin : Vector3, length : number, color : number | Color | string, headLength : number, headWidth : number )
+
+Constructs a new arrow helper.
+
+**dir**
+
+The (normalized) direction vector.
+
+Default is `(0, 0, 1)`.
+
+**origin**
+
+Point at which the arrow starts.
+
+Default is `(0, 0, 0)`.
+
+**length**
+
+Length of the arrow in world units.
+
+Default is `1`.
+
+**color**
+
+Color of the arrow.
+
+Default is `0xffff00`.
+
+**headLength**
+
+The length of the head of the arrow.
+
+Default is `length*0.2`.
+
+**headWidth**
+
+The width of the head of the arrow.
+
+Default is `headLength*0.2`.
+
+## Properties
+
+### .cone : Mesh
+
+The cone part of the arrow helper.
+
+### .line : Line
+
+The line part of the arrow helper.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+### .setColor( color : number | Color | string )
+
+Sets the color of the helper.
+
+**color**
+
+The color to set.
+
+### .setDirection( dir : Vector3 )
+
+Sets the direction of the helper.
+
+**dir**
+
+The normalized direction vector.
+
+### .setLength( length : number, headLength : number, headWidth : number )
+
+Sets the length of the helper.
+
+**length**
+
+Length of the arrow in world units.
+
+**headLength**
+
+The length of the head of the arrow.
+
+Default is `length*0.2`.
+
+**headWidth**
+
+The width of the head of the arrow.
+
+Default is `headLength*0.2`.
+
+## Source
+
+[src/helpers/ArrowHelper.js](https://github.com/mrdoob/three.js/blob/master/src/helpers/ArrowHelper.js)
\ No newline at end of file
diff --git a/docs/pages/AsciiEffect.html.md b/docs/pages/AsciiEffect.html.md
new file mode 100644
index 00000000000000..0453fa44f9c683
--- /dev/null
+++ b/docs/pages/AsciiEffect.html.md
@@ -0,0 +1,124 @@
+# AsciiEffect
+
+A class that creates an ASCII effect.
+
+The ASCII generation is based on [jsascii](https://github.com/hassadee/jsascii/blob/master/jsascii.js).
+
+## Import
+
+AsciiEffect is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { AsciiEffect } from 'three/addons/effects/AsciiEffect.js';
+```
+
+## Constructor
+
+### new AsciiEffect( renderer : WebGLRenderer, charSet : string, options : AsciiEffect~Options )
+
+Constructs a new ASCII effect.
+
+**renderer**
+
+The renderer.
+
+**charSet**
+
+The char set.
+
+Default is `' .:-=+*#%@'`.
+
+**options**
+
+The configuration parameter.
+
+## Properties
+
+### .domElement : HTMLDivElement
+
+The DOM element of the effect. This element must be used instead of the default [WebGLRenderer#domElement](WebGLRenderer.html#domElement).
+
+## Methods
+
+### .render( scene : Object3D, camera : Camera )
+
+When using this effect, this method should be called instead of the default [WebGLRenderer#render](WebGLRenderer.html#render).
+
+**scene**
+
+The scene to render.
+
+**camera**
+
+The camera.
+
+### .setSize( w : number, h : number )
+
+Resizes the effect.
+
+**w**
+
+The width of the effect in logical pixels.
+
+**h**
+
+The height of the effect in logical pixels.
+
+## Type Definitions
+
+### .Options
+
+This type represents configuration settings of `AsciiEffect`.
+
+**resolution**
+number
+
+A higher value leads to more details.
+
+Default is `0.15`.
+
+**scale**
+number
+
+The scale of the effect.
+
+Default is `1`.
+
+**color**
+boolean
+
+Whether colors should be enabled or not. Better quality but slows down rendering.
+
+Default is `false`.
+
+**alpha**
+boolean
+
+Whether transparency should be enabled or not.
+
+Default is `false`.
+
+**block**
+boolean
+
+Whether blocked characters should be enabled or not.
+
+Default is `false`.
+
+**invert**
+boolean
+
+Whether colors should be inverted or not.
+
+Default is `false`.
+
+**strResolution**
+'low' | 'medium' | 'high'
+
+The string resolution.
+
+Default is `'low'`.
+
+## Source
+
+[examples/jsm/effects/AsciiEffect.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/effects/AsciiEffect.js)
\ No newline at end of file
diff --git a/docs/pages/AssignNode.html.md b/docs/pages/AssignNode.html.md
new file mode 100644
index 00000000000000..eecb1e51f919dc
--- /dev/null
+++ b/docs/pages/AssignNode.html.md
@@ -0,0 +1,59 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# AssignNode
+
+These node represents an assign operation. Meaning a node is assigned to another node.
+
+## Constructor
+
+### new AssignNode( targetNode : Node, sourceNode : Node )
+
+Constructs a new assign node.
+
+**targetNode**
+
+The target node.
+
+**sourceNode**
+
+The source type.
+
+## Properties
+
+### .isAssignNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .sourceNode : Node
+
+The source node.
+
+### .targetNode : Node
+
+The target node.
+
+## Methods
+
+### .hasDependencies() : boolean
+
+Whether this node is used more than once in context of other nodes. This method is overwritten since it always returns `false` (assigns are unique).
+
+**Overrides:** [TempNode#hasDependencies](TempNode.html#hasDependencies)
+
+**Returns:** A flag that indicates if there is more than one dependency to other nodes. Always `false`.
+
+### .needsSplitAssign( builder : NodeBuilder ) : boolean
+
+Whether a split is required when assigning source to target. This can happen when the component length of target and source data type does not match.
+
+**builder**
+
+The current node builder.
+
+**Returns:** Whether a split is required when assigning source to target.
+
+## Source
+
+[src/nodes/core/AssignNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/core/AssignNode.js)
\ No newline at end of file
diff --git a/docs/pages/AtomicFunctionNode.html.md b/docs/pages/AtomicFunctionNode.html.md
new file mode 100644
index 00000000000000..4d3c75e9944a88
--- /dev/null
+++ b/docs/pages/AtomicFunctionNode.html.md
@@ -0,0 +1,75 @@
+*Inheritance: EventDispatcher → Node →*
+
+# AtomicFunctionNode
+
+`AtomicFunctionNode` represents any function that can operate on atomic variable types within a shader. In an atomic function, any modification to an atomic variable will occur as an indivisible step with a defined order relative to other modifications. Accordingly, even if multiple atomic functions are modifying an atomic variable at once atomic operations will not interfere with each other.
+
+This node can only be used with a WebGPU backend.
+
+## Constructor
+
+### new AtomicFunctionNode( method : string, pointerNode : Node, valueNode : Node )
+
+Constructs a new atomic function node.
+
+**method**
+
+The signature of the atomic function to construct.
+
+**pointerNode**
+
+An atomic variable or element of an atomic buffer.
+
+**valueNode**
+
+The value that mutates the atomic variable.
+
+## Properties
+
+### .method : string
+
+The signature of the atomic function to construct.
+
+### .parents : boolean
+
+Creates a list of the parents for this node for detecting if the node needs to return a value.
+
+Default is `true`.
+
+**Overrides:** [Node#parents](Node.html#parents)
+
+### .pointerNode : Node
+
+An atomic variable or element of an atomic buffer.
+
+### .valueNode : Node
+
+A value that modifies the atomic variable.
+
+## Methods
+
+### .getInputType( builder : NodeBuilder ) : string
+
+Overwrites the default implementation to return the type of the pointer node.
+
+**builder**
+
+The current node builder.
+
+**Returns:** The input type.
+
+### .getNodeType( builder : NodeBuilder ) : string
+
+Overwritten since the node type is inferred from the input type.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [Node#getNodeType](Node.html#getNodeType)
+
+**Returns:** The node type.
+
+## Source
+
+[src/nodes/gpgpu/AtomicFunctionNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/gpgpu/AtomicFunctionNode.js)
\ No newline at end of file
diff --git a/docs/pages/AttributeNode.html.md b/docs/pages/AttributeNode.html.md
new file mode 100644
index 00000000000000..d5b36d120a0353
--- /dev/null
+++ b/docs/pages/AttributeNode.html.md
@@ -0,0 +1,57 @@
+*Inheritance: EventDispatcher → Node →*
+
+# AttributeNode
+
+Base class for representing shader attributes as nodes.
+
+## Constructor
+
+### new AttributeNode( attributeName : string, nodeType : string )
+
+Constructs a new attribute node.
+
+**attributeName**
+
+The name of the attribute.
+
+**nodeType**
+
+The node type.
+
+Default is `null`.
+
+## Properties
+
+### .global : boolean
+
+`AttributeNode` sets this property to `true` by default.
+
+Default is `true`.
+
+**Overrides:** [Node#global](Node.html#global)
+
+## Methods
+
+### .getAttributeName( builder : NodeBuilder ) : string
+
+Returns the attribute name of this node. The method can be overwritten in derived classes if the final name must be computed analytically.
+
+**builder**
+
+The current node builder.
+
+**Returns:** The attribute name.
+
+### .setAttributeName( attributeName : string ) : AttributeNode
+
+Sets the attribute name to the given value. The method can be overwritten in derived classes if the final name must be computed analytically.
+
+**attributeName**
+
+The name of the attribute.
+
+**Returns:** A reference to this node.
+
+## Source
+
+[src/nodes/core/AttributeNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/core/AttributeNode.js)
\ No newline at end of file
diff --git a/docs/pages/Audio.html.md b/docs/pages/Audio.html.md
new file mode 100644
index 00000000000000..7fc915cd4a7776
--- /dev/null
+++ b/docs/pages/Audio.html.md
@@ -0,0 +1,383 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# Audio
+
+Represents a non-positional ( global ) audio object.
+
+This and related audio modules make use of the [Web Audio API](https://www.w3.org/TR/webaudio-1.1/).
+
+## Code Example
+
+```js
+// create an AudioListener and add it to the camera
+const listener = new THREE.AudioListener();
+camera.add( listener );
+// create a global audio source
+const sound = new THREE.Audio( listener );
+// load a sound and set it as the Audio object's buffer
+const audioLoader = new THREE.AudioLoader();
+audioLoader.load( 'sounds/ambient.ogg', function( buffer ) {
+ sound.setBuffer( buffer );
+ sound.setLoop( true );
+ sound.setVolume( 0.5 );
+ sound.play();
+});
+```
+
+## Constructor
+
+### new Audio( listener : AudioListener )
+
+Constructs a new audio.
+
+**listener**
+
+The global audio listener.
+
+## Properties
+
+### .autoplay : boolean
+
+Whether to start playback automatically or not.
+
+Default is `false`.
+
+### .buffer : AudioBuffer (readonly)
+
+A reference to an audio buffer.
+
+Defined via [Audio#setBuffer](Audio.html#setBuffer).
+
+Default is `null`.
+
+### .context : AudioContext (readonly)
+
+The audio context.
+
+### .detune : number (readonly)
+
+Modify pitch, measured in cents. +/- 100 is a semitone. +/- 1200 is an octave.
+
+Defined via [Audio#setDetune](Audio.html#setDetune).
+
+Default is `0`.
+
+### .duration : undefined | number
+
+Overrides the default duration of the audio.
+
+Default is `undefined`.
+
+### .filters : Array. (readonly)
+
+Can be used to apply a variety of low-order filters to create more complex sound effects e.g. via `BiquadFilterNode`.
+
+The property is automatically set by [Audio#setFilters](Audio.html#setFilters).
+
+### .gain : GainNode (readonly)
+
+The gain node used for volume control.
+
+### .hasPlaybackControl : boolean (readonly)
+
+Indicates whether the audio playback can be controlled with method like [Audio#play](Audio.html#play) or [Audio#pause](Audio.html#pause).
+
+This flag will be automatically set when audio sources are defined.
+
+Default is `true`.
+
+### .isPlaying : boolean (readonly)
+
+Indicates whether the audio is playing or not.
+
+This flag will be automatically set when using [Audio#play](Audio.html#play), [Audio#pause](Audio.html#pause), [Audio#stop](Audio.html#stop).
+
+Default is `false`.
+
+### .listener : AudioListener (readonly)
+
+The global audio listener.
+
+### .loop : boolean (readonly)
+
+Whether the audio should loop or not.
+
+Defined via [Audio#setLoop](Audio.html#setLoop).
+
+Default is `false`.
+
+### .loopEnd : number
+
+Defines where in the audio buffer the replay should stop, in seconds.
+
+Default is `0`.
+
+### .loopStart : number
+
+Defines where in the audio buffer the replay should start, in seconds.
+
+Default is `0`.
+
+### .offset : number
+
+An offset to the time within the audio buffer the playback should begin, in seconds.
+
+Default is `0`.
+
+### .playbackRate : number (readonly)
+
+The playback speed.
+
+Defined via [Audio#setPlaybackRate](Audio.html#setPlaybackRate).
+
+Default is `1`.
+
+### .source : AudioNode (readonly)
+
+Holds a reference to the current audio source.
+
+The property is automatically by one of the `set*()` methods.
+
+Default is `null`.
+
+### .sourceType : 'empty' | 'audioNode' | 'mediaNode' | 'mediaStreamNode' | 'buffer' (readonly)
+
+Defines the source type.
+
+The property is automatically set by one of the `set*()` methods.
+
+Default is `'empty'`.
+
+## Methods
+
+### .connect() : Audio
+
+Connects to the audio source. This is used internally on initialisation and when setting / removing filters.
+
+**Returns:** A reference to this instance.
+
+### .disconnect() : Audio | undefined
+
+Disconnects to the audio source. This is used internally on initialisation and when setting / removing filters.
+
+**Returns:** A reference to this instance.
+
+### .getDetune() : number
+
+Returns the detuning of oscillation in cents.
+
+**Returns:** The detuning of oscillation in cents.
+
+### .getFilter() : AudioNode | undefined
+
+Returns the first filter in the list of filters.
+
+**Returns:** The first filter in the list of filters.
+
+### .getFilters() : Array.
+
+Returns the current set filters.
+
+**Returns:** The list of filters.
+
+### .getLoop() : boolean
+
+Returns the loop flag.
+
+Can only be used with compatible audio sources that allow playback control.
+
+**Returns:** Whether the audio should loop or not.
+
+### .getOutput() : GainNode
+
+Returns the output audio node.
+
+**Returns:** The output node.
+
+### .getPlaybackRate() : number
+
+Returns the current playback rate.
+
+**Returns:** The playback rate.
+
+### .getVolume() : number
+
+Returns the volume.
+
+**Returns:** The volume.
+
+### .onEnded()
+
+Automatically called when playback finished.
+
+### .pause() : Audio | undefined
+
+Pauses the playback of the audio.
+
+Can only be used with compatible audio sources that allow playback control.
+
+**Returns:** A reference to this instance.
+
+### .play( delay : number ) : Audio | undefined
+
+Starts the playback of the audio.
+
+Can only be used with compatible audio sources that allow playback control.
+
+**delay**
+
+The delay, in seconds, at which the audio should start playing.
+
+Default is `0`.
+
+**Returns:** A reference to this instance.
+
+### .setBuffer( audioBuffer : AudioBuffer ) : Audio
+
+Sets the given audio buffer as the source of this instance.
+
+[Audio#sourceType](Audio.html#sourceType) is set to `buffer` and [Audio#hasPlaybackControl](Audio.html#hasPlaybackControl) to `true`.
+
+**audioBuffer**
+
+The audio buffer.
+
+**Returns:** A reference to this instance.
+
+### .setDetune( value : number ) : Audio
+
+Defines the detuning of oscillation in cents.
+
+**value**
+
+The detuning of oscillation in cents.
+
+**Returns:** A reference to this instance.
+
+### .setFilter( filter : AudioNode ) : Audio
+
+Applies a single filter node to the audio.
+
+**filter**
+
+The filter to set.
+
+**Returns:** A reference to this instance.
+
+### .setFilters( value : Array. ) : Audio
+
+Sets an array of filters and connects them with the audio source.
+
+**value**
+
+A list of filters.
+
+**Returns:** A reference to this instance.
+
+### .setLoop( value : boolean ) : Audio | undefined
+
+Sets the loop flag.
+
+Can only be used with compatible audio sources that allow playback control.
+
+**value**
+
+Whether the audio should loop or not.
+
+**Returns:** A reference to this instance.
+
+### .setLoopEnd( value : number ) : Audio
+
+Sets the loop end value which defines where in the audio buffer the replay should stop, in seconds.
+
+**value**
+
+The loop end value.
+
+**Returns:** A reference to this instance.
+
+### .setLoopStart( value : number ) : Audio
+
+Sets the loop start value which defines where in the audio buffer the replay should start, in seconds.
+
+**value**
+
+The loop start value.
+
+**Returns:** A reference to this instance.
+
+### .setMediaElementSource( mediaElement : HTMLMediaElement ) : Audio
+
+Sets the given media element as the source of this instance.
+
+[Audio#sourceType](Audio.html#sourceType) is set to `mediaNode` and [Audio#hasPlaybackControl](Audio.html#hasPlaybackControl) to `false`.
+
+**mediaElement**
+
+The media element.
+
+**Returns:** A reference to this instance.
+
+### .setMediaStreamSource( mediaStream : MediaStream ) : Audio
+
+Sets the given media stream as the source of this instance.
+
+[Audio#sourceType](Audio.html#sourceType) is set to `mediaStreamNode` and [Audio#hasPlaybackControl](Audio.html#hasPlaybackControl) to `false`.
+
+**mediaStream**
+
+The media stream.
+
+**Returns:** A reference to this instance.
+
+### .setNodeSource( audioNode : AudioNode ) : Audio
+
+Sets the given audio node as the source of this instance.
+
+[Audio#sourceType](Audio.html#sourceType) is set to `audioNode` and [Audio#hasPlaybackControl](Audio.html#hasPlaybackControl) to `false`.
+
+**audioNode**
+
+The audio node like an instance of `OscillatorNode`.
+
+**Returns:** A reference to this instance.
+
+### .setPlaybackRate( value : number ) : Audio | undefined
+
+Sets the playback rate.
+
+Can only be used with compatible audio sources that allow playback control.
+
+**value**
+
+The playback rate to set.
+
+**Returns:** A reference to this instance.
+
+### .setVolume( value : number ) : Audio
+
+Sets the volume.
+
+**value**
+
+The volume to set.
+
+**Returns:** A reference to this instance.
+
+### .stop( delay : number ) : Audio | undefined
+
+Stops the playback of the audio.
+
+Can only be used with compatible audio sources that allow playback control.
+
+**delay**
+
+The delay, in seconds, at which the audio should stop playing.
+
+Default is `0`.
+
+**Returns:** A reference to this instance.
+
+## Source
+
+[src/audio/Audio.js](https://github.com/mrdoob/three.js/blob/master/src/audio/Audio.js)
\ No newline at end of file
diff --git a/docs/pages/AudioAnalyser.html.md b/docs/pages/AudioAnalyser.html.md
new file mode 100644
index 00000000000000..44e161d8126b7c
--- /dev/null
+++ b/docs/pages/AudioAnalyser.html.md
@@ -0,0 +1,71 @@
+# AudioAnalyser
+
+This class can be used to analyse audio data.
+
+## Code Example
+
+```js
+// create an AudioListener and add it to the camera
+const listener = new THREE.AudioListener();
+camera.add( listener );
+// create an Audio source
+const sound = new THREE.Audio( listener );
+// load a sound and set it as the Audio object's buffer
+const audioLoader = new THREE.AudioLoader();
+audioLoader.load( 'sounds/ambient.ogg', function( buffer ) {
+ sound.setBuffer( buffer );
+ sound.setLoop(true);
+ sound.setVolume(0.5);
+ sound.play();
+});
+// create an AudioAnalyser, passing in the sound and desired fftSize
+const analyser = new THREE.AudioAnalyser( sound, 32 );
+// get the average frequency of the sound
+const data = analyser.getAverageFrequency();
+```
+
+## Constructor
+
+### new AudioAnalyser( audio : Audio, fftSize : number )
+
+Constructs a new audio analyzer.
+
+**audio**
+
+The audio to analyze.
+
+**fftSize**
+
+The window size in samples that is used when performing a Fast Fourier Transform (FFT) to get frequency domain data.
+
+Default is `2048`.
+
+## Properties
+
+### .analyser : AnalyserNode
+
+The global audio listener.
+
+### .data : Uint8Array
+
+Holds the analyzed data.
+
+## Methods
+
+### .getAverageFrequency() : number
+
+Returns the average of the frequencies returned by [AudioAnalyser#getFrequencyData](AudioAnalyser.html#getFrequencyData).
+
+**Returns:** The average frequency.
+
+### .getFrequencyData() : Uint8Array
+
+Returns an array with frequency data of the audio.
+
+Each item in the array represents the decibel value for a specific frequency. The frequencies are spread linearly from 0 to 1/2 of the sample rate. For example, for 48000 sample rate, the last item of the array will represent the decibel value for 24000 Hz.
+
+**Returns:** The frequency data.
+
+## Source
+
+[src/audio/AudioAnalyser.js](https://github.com/mrdoob/three.js/blob/master/src/audio/AudioAnalyser.js)
\ No newline at end of file
diff --git a/docs/pages/AudioContext.html.md b/docs/pages/AudioContext.html.md
new file mode 100644
index 00000000000000..626b645489030b
--- /dev/null
+++ b/docs/pages/AudioContext.html.md
@@ -0,0 +1,23 @@
+# AudioContext
+
+Manages the global audio context in the engine.
+
+## Static Methods
+
+### .getContext() : AudioContext
+
+Returns the global native audio context.
+
+**Returns:** The native audio context.
+
+### .setContext( value : AudioContext )
+
+Allows to set the global native audio context from outside.
+
+**value**
+
+The native context to set.
+
+## Source
+
+[src/audio/AudioContext.js](https://github.com/mrdoob/three.js/blob/master/src/audio/AudioContext.js)
\ No newline at end of file
diff --git a/docs/pages/AudioListener.html.md b/docs/pages/AudioListener.html.md
new file mode 100644
index 00000000000000..8701f6c08ca97f
--- /dev/null
+++ b/docs/pages/AudioListener.html.md
@@ -0,0 +1,89 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# AudioListener
+
+The class represents a virtual listener of the all positional and non-positional audio effects in the scene. A three.js application usually creates a single listener. It is a mandatory constructor parameter for audios entities like [Audio](Audio.html) and [PositionalAudio](PositionalAudio.html).
+
+In most cases, the listener object is a child of the camera. So the 3D transformation of the camera represents the 3D transformation of the listener.
+
+## Constructor
+
+### new AudioListener()
+
+Constructs a new audio listener.
+
+## Properties
+
+### .context : AudioContext (readonly)
+
+The native audio context.
+
+### .filter : AudioNode (readonly)
+
+An optional filter.
+
+Defined via [AudioListener#setFilter](AudioListener.html#setFilter).
+
+Default is `null`.
+
+### .gain : GainNode (readonly)
+
+The gain node used for volume control.
+
+### .timeDelta : number (readonly)
+
+Time delta values required for `linearRampToValueAtTime()` usage.
+
+Default is `0`.
+
+## Methods
+
+### .getFilter() : AudioNode
+
+Returns the current set filter.
+
+**Returns:** The filter.
+
+### .getInput() : GainNode
+
+Returns the listener's input node.
+
+This method is used by other audio nodes to connect to this listener.
+
+**Returns:** The input node.
+
+### .getMasterVolume() : number
+
+Returns the applications master volume.
+
+**Returns:** The master volume.
+
+### .removeFilter() : AudioListener
+
+Removes the current filter from this listener.
+
+**Returns:** A reference to this listener.
+
+### .setFilter( value : AudioNode ) : AudioListener
+
+Sets the given filter to this listener.
+
+**value**
+
+The filter to set.
+
+**Returns:** A reference to this listener.
+
+### .setMasterVolume( value : number ) : AudioListener
+
+Sets the applications master volume. This volume setting affects all audio nodes in the scene.
+
+**value**
+
+The master volume to set.
+
+**Returns:** A reference to this listener.
+
+## Source
+
+[src/audio/AudioListener.js](https://github.com/mrdoob/three.js/blob/master/src/audio/AudioListener.js)
\ No newline at end of file
diff --git a/docs/pages/AudioLoader.html.md b/docs/pages/AudioLoader.html.md
new file mode 100644
index 00000000000000..33ca04992365a3
--- /dev/null
+++ b/docs/pages/AudioLoader.html.md
@@ -0,0 +1,54 @@
+*Inheritance: Loader →*
+
+# AudioLoader
+
+Class for loading audio buffers. Audios are internally loaded via [FileLoader](FileLoader.html).
+
+## Code Example
+
+```js
+const audioListener = new THREE.AudioListener();
+const ambientSound = new THREE.Audio( audioListener );
+const loader = new THREE.AudioLoader();
+const audioBuffer = await loader.loadAsync( 'audio/ambient_ocean.ogg' );
+ambientSound.setBuffer( audioBuffer );
+ambientSound.play();
+```
+
+## Constructor
+
+### new AudioLoader( manager : LoadingManager )
+
+Constructs a new audio loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded audio buffer to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+## Source
+
+[src/loaders/AudioLoader.js](https://github.com/mrdoob/three.js/blob/master/src/loaders/AudioLoader.js)
\ No newline at end of file
diff --git a/docs/pages/AxesHelper.html.md b/docs/pages/AxesHelper.html.md
new file mode 100644
index 00000000000000..e22f5a9f445daf
--- /dev/null
+++ b/docs/pages/AxesHelper.html.md
@@ -0,0 +1,52 @@
+*Inheritance: EventDispatcher → Object3D → Line → LineSegments →*
+
+# AxesHelper
+
+An axis object to visualize the 3 axes in a simple way. The X axis is red. The Y axis is green. The Z axis is blue.
+
+## Code Example
+
+```js
+const axesHelper = new THREE.AxesHelper( 5 );
+scene.add( axesHelper );
+```
+
+## Constructor
+
+### new AxesHelper( size : number )
+
+Constructs a new axes helper.
+
+**size**
+
+Size of the lines representing the axes.
+
+Default is `1`.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+### .setColors( xAxisColor : number | Color | string, yAxisColor : number | Color | string, zAxisColor : number | Color | string ) : AxesHelper
+
+Defines the colors of the axes helper.
+
+**xAxisColor**
+
+The color for the x axis.
+
+**yAxisColor**
+
+The color for the y axis.
+
+**zAxisColor**
+
+The color for the z axis.
+
+**Returns:** A reference to this axes helper.
+
+## Source
+
+[src/helpers/AxesHelper.js](https://github.com/mrdoob/three.js/blob/master/src/helpers/AxesHelper.js)
\ No newline at end of file
diff --git a/docs/pages/BVHLoader.html.md b/docs/pages/BVHLoader.html.md
new file mode 100644
index 00000000000000..6e0beeb62e718b
--- /dev/null
+++ b/docs/pages/BVHLoader.html.md
@@ -0,0 +1,93 @@
+*Inheritance: Loader →*
+
+# BVHLoader
+
+A loader for the BVH format.
+
+Imports BVH files and outputs a single [Skeleton](Skeleton.html) and [AnimationClip](AnimationClip.html). The loader only supports BVH files containing a single root right now.
+
+## Code Example
+
+```js
+const loader = new BVHLoader();
+const result = await loader.loadAsync( 'models/bvh/pirouette.bvh' );
+// visualize skeleton
+const skeletonHelper = new THREE.SkeletonHelper( result.skeleton.bones[ 0 ] );
+scene.add( result.skeleton.bones[ 0 ] );
+scene.add( skeletonHelper );
+// play animation clip
+mixer = new THREE.AnimationMixer( result.skeleton.bones[ 0 ] );
+mixer.clipAction( result.clip ).play();
+```
+
+## Import
+
+BVHLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { BVHLoader } from 'three/addons/loaders/BVHLoader.js';
+```
+
+## Constructor
+
+### new BVHLoader( manager : LoadingManager )
+
+Constructs a new BVH loader.
+
+**manager**
+
+The loading manager.
+
+## Properties
+
+### .animateBonePositions : boolean
+
+Whether to animate bone positions or not.
+
+Default is `true`.
+
+### .animateBoneRotations : boolean
+
+Whether to animate bone rotations or not.
+
+Default is `true`.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded BVH asset to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( text : string ) : Object
+
+Parses the given BVH data and returns the resulting data.
+
+**text**
+
+The raw BVH data as a string.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** An object representing the parsed asset.
+
+## Source
+
+[examples/jsm/loaders/BVHLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/BVHLoader.js)
\ No newline at end of file
diff --git a/docs/pages/BarrierNode.html.md b/docs/pages/BarrierNode.html.md
new file mode 100644
index 00000000000000..a02afb3af7e7ad
--- /dev/null
+++ b/docs/pages/BarrierNode.html.md
@@ -0,0 +1,21 @@
+*Inheritance: EventDispatcher → Node →*
+
+# BarrierNode
+
+Represents a GPU control barrier that synchronizes compute operations within a given scope.
+
+This node can only be used with a WebGPU backend.
+
+## Constructor
+
+### new BarrierNode( scope : string )
+
+Constructs a new barrier node.
+
+**scope**
+
+The scope defines the behavior of the node.
+
+## Source
+
+[src/nodes/gpgpu/BarrierNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/gpgpu/BarrierNode.js)
\ No newline at end of file
diff --git a/docs/pages/BasicEnvironmentNode.html.md b/docs/pages/BasicEnvironmentNode.html.md
new file mode 100644
index 00000000000000..6837ef842641d5
--- /dev/null
+++ b/docs/pages/BasicEnvironmentNode.html.md
@@ -0,0 +1,29 @@
+*Inheritance: EventDispatcher → Node → LightingNode →*
+
+# BasicEnvironmentNode
+
+Represents a basic model for Image-based lighting (IBL). The environment is defined via environment maps in the equirectangular or cube map format. `BasicEnvironmentNode` is intended for non-PBR materials like [MeshBasicNodeMaterial](MeshBasicNodeMaterial.html) or [MeshPhongNodeMaterial](MeshPhongNodeMaterial.html).
+
+## Constructor
+
+### new BasicEnvironmentNode( envNode : Node )
+
+Constructs a new basic environment node.
+
+**envNode**
+
+A node representing the environment.
+
+Default is `null`.
+
+## Properties
+
+### .envNode : Node
+
+A node representing the environment.
+
+Default is `null`.
+
+## Source
+
+[src/nodes/lighting/BasicEnvironmentNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/lighting/BasicEnvironmentNode.js)
\ No newline at end of file
diff --git a/docs/pages/BasicLightMapNode.html.md b/docs/pages/BasicLightMapNode.html.md
new file mode 100644
index 00000000000000..2d8bc671fb9d85
--- /dev/null
+++ b/docs/pages/BasicLightMapNode.html.md
@@ -0,0 +1,27 @@
+*Inheritance: EventDispatcher → Node → LightingNode →*
+
+# BasicLightMapNode
+
+A specific version of [IrradianceNode](IrradianceNode.html) that is only relevant for [MeshBasicNodeMaterial](MeshBasicNodeMaterial.html). Since the material is unlit, it requires a special scaling factor for the light map.
+
+## Constructor
+
+### new BasicLightMapNode( lightMapNode : Node. )
+
+Constructs a new basic light map node.
+
+**lightMapNode**
+
+The light map node.
+
+Default is `null`.
+
+## Properties
+
+### .lightMapNode : Node.
+
+The light map node.
+
+## Source
+
+[src/nodes/lighting/BasicLightMapNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/lighting/BasicLightMapNode.js)
\ No newline at end of file
diff --git a/docs/pages/BasicLightingModel.html.md b/docs/pages/BasicLightingModel.html.md
new file mode 100644
index 00000000000000..d285d8db317da8
--- /dev/null
+++ b/docs/pages/BasicLightingModel.html.md
@@ -0,0 +1,37 @@
+*Inheritance: LightingModel →*
+
+# BasicLightingModel
+
+Represents the lighting model for unlit materials. The only light contribution is baked indirect lighting modulated with ambient occlusion and the material's diffuse color. Environment mapping is supported. Used in [MeshBasicNodeMaterial](MeshBasicNodeMaterial.html).
+
+## Constructor
+
+### new BasicLightingModel()
+
+Constructs a new basic lighting model.
+
+## Methods
+
+### .finish( builder : NodeBuilder )
+
+Implements the environment mapping.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [LightingModel#finish](LightingModel.html#finish)
+
+### .indirect( builder : NodeBuilder )
+
+Implements the baked indirect lighting with its modulation.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [LightingModel#indirect](LightingModel.html#indirect)
+
+## Source
+
+[src/nodes/functions/BasicLightingModel.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/functions/BasicLightingModel.js)
\ No newline at end of file
diff --git a/docs/pages/BatchNode.html.md b/docs/pages/BatchNode.html.md
new file mode 100644
index 00000000000000..47e2452c793af4
--- /dev/null
+++ b/docs/pages/BatchNode.html.md
@@ -0,0 +1,43 @@
+*Inheritance: EventDispatcher → Node →*
+
+# BatchNode
+
+This node implements the vertex shader logic which is required when rendering 3D objects via batching. `BatchNode` must be used with instances of [BatchedMesh](BatchedMesh.html).
+
+## Constructor
+
+### new BatchNode( batchMesh : BatchedMesh )
+
+Constructs a new batch node.
+
+**batchMesh**
+
+A reference to batched mesh.
+
+## Properties
+
+### .batchMesh : BatchedMesh
+
+A reference to batched mesh.
+
+### .batchingIdNode : IndexNode
+
+The batching index node.
+
+Default is `null`.
+
+## Methods
+
+### .setup( builder : NodeBuilder )
+
+Setups the internal buffers and nodes and assigns the transformed vertex data to predefined node variables for accumulation. That follows the same patterns like with morph and skinning nodes.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [Node#setup](Node.html#setup)
+
+## Source
+
+[src/nodes/accessors/BatchNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/accessors/BatchNode.js)
\ No newline at end of file
diff --git a/docs/pages/BatchedMesh.html.md b/docs/pages/BatchedMesh.html.md
new file mode 100644
index 00000000000000..0dc601dcc0a4b2
--- /dev/null
+++ b/docs/pages/BatchedMesh.html.md
@@ -0,0 +1,388 @@
+*Inheritance: EventDispatcher → Object3D → Mesh →*
+
+# BatchedMesh
+
+A special version of a mesh with multi draw batch rendering support. Use this class if you have to render a large number of objects with the same material but with different geometries or world transformations. The usage of `BatchedMesh` will help you to reduce the number of draw calls and thus improve the overall rendering performance in your application.
+
+## Code Example
+
+```js
+const box = new THREE.BoxGeometry( 1, 1, 1 );
+const sphere = new THREE.SphereGeometry( 1, 12, 12 );
+const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
+// initialize and add geometries into the batched mesh
+const batchedMesh = new BatchedMesh( 10, 5000, 10000, material );
+const boxGeometryId = batchedMesh.addGeometry( box );
+const sphereGeometryId = batchedMesh.addGeometry( sphere );
+// create instances of those geometries
+const boxInstancedId1 = batchedMesh.addInstance( boxGeometryId );
+const boxInstancedId2 = batchedMesh.addInstance( boxGeometryId );
+const sphereInstancedId1 = batchedMesh.addInstance( sphereGeometryId );
+const sphereInstancedId2 = batchedMesh.addInstance( sphereGeometryId );
+// position the geometries
+batchedMesh.setMatrixAt( boxInstancedId1, boxMatrix1 );
+batchedMesh.setMatrixAt( boxInstancedId2, boxMatrix2 );
+batchedMesh.setMatrixAt( sphereInstancedId1, sphereMatrix1 );
+batchedMesh.setMatrixAt( sphereInstancedId2, sphereMatrix2 );
+scene.add( batchedMesh );
+```
+
+## Constructor
+
+### new BatchedMesh( maxInstanceCount : number, maxVertexCount : number, maxIndexCount : number, material : Material | Array. )
+
+Constructs a new batched mesh.
+
+**maxInstanceCount**
+
+The maximum number of individual instances planned to be added and rendered.
+
+**maxVertexCount**
+
+The maximum number of vertices to be used by all unique geometries.
+
+**maxIndexCount**
+
+The maximum number of indices to be used by all unique geometries
+
+Default is `maxVertexCount*2`.
+
+**material**
+
+The mesh material.
+
+## Properties
+
+### .boundingBox : Box3
+
+The bounding box of the batched mesh. Can be computed via [BatchedMesh#computeBoundingBox](BatchedMesh.html#computeBoundingBox).
+
+Default is `null`.
+
+### .boundingSphere : Sphere
+
+The bounding sphere of the batched mesh. Can be computed via [BatchedMesh#computeBoundingSphere](BatchedMesh.html#computeBoundingSphere).
+
+Default is `null`.
+
+### .customSort : function
+
+Takes a sort a function that is run before render. The function takes a list of instances to sort and a camera. The objects in the list include a "z" field to perform a depth-ordered sort with.
+
+Default is `null`.
+
+### .instanceCount : number (readonly)
+
+The instance count.
+
+### .isBatchedMesh : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .maxInstanceCount : number (readonly)
+
+The maximum number of individual instances that can be stored in the batch.
+
+### .perObjectFrustumCulled : boolean
+
+When set ot `true`, the individual objects of a batch are frustum culled.
+
+Default is `true`.
+
+### .sortObjects : boolean
+
+When set to `true`, the individual objects of a batch are sorted to improve overdraw-related artifacts. If the material is marked as "transparent" objects are rendered back to front and if not then they are rendered front to back.
+
+Default is `true`.
+
+### .unusedIndexCount : number (readonly)
+
+The number of unused indices.
+
+### .unusedVertexCount : number (readonly)
+
+The number of unused vertices.
+
+## Methods
+
+### .addGeometry( geometry : BufferGeometry, reservedVertexCount : number, reservedIndexCount : number ) : number
+
+Adds the given geometry to the batch and returns the associated geometry id referring to it to be used in other functions.
+
+**geometry**
+
+The geometry to add.
+
+**reservedVertexCount**
+
+Optional parameter specifying the amount of vertex buffer space to reserve for the added geometry. This is necessary if it is planned to set a new geometry at this index at a later time that is larger than the original geometry. Defaults to the length of the given geometry vertex buffer.
+
+Default is `-1`.
+
+**reservedIndexCount**
+
+Optional parameter specifying the amount of index buffer space to reserve for the added geometry. This is necessary if it is planned to set a new geometry at this index at a later time that is larger than the original geometry. Defaults to the length of the given geometry index buffer.
+
+Default is `-1`.
+
+**Returns:** The geometry ID.
+
+### .addInstance( geometryId : number ) : number
+
+Adds a new instance to the batch using the geometry of the given ID and returns a new id referring to the new instance to be used by other functions.
+
+**geometryId**
+
+The ID of a previously added geometry via [BatchedMesh#addGeometry](BatchedMesh.html#addGeometry).
+
+**Returns:** The instance ID.
+
+### .computeBoundingBox()
+
+Computes the bounding box, updating [BatchedMesh#boundingBox](BatchedMesh.html#boundingBox). Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+
+### .computeBoundingSphere()
+
+Computes the bounding sphere, updating [BatchedMesh#boundingSphere](BatchedMesh.html#boundingSphere). Bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+
+### .deleteGeometry( geometryId : number ) : BatchedMesh
+
+Deletes the geometry defined by the given ID from this batch. Any instances referencing this geometry will also be removed as a side effect.
+
+**geometryId**
+
+The ID of the geometry to remove from the batch.
+
+**Returns:** A reference to this batched mesh.
+
+### .deleteInstance( instanceId : number ) : BatchedMesh
+
+Deletes an existing instance from the batch using the given ID.
+
+**instanceId**
+
+The ID of the instance to remove from the batch.
+
+**Returns:** A reference to this batched mesh.
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+### .getBoundingBoxAt( geometryId : number, target : Box3 ) : Box3
+
+Returns the bounding box for the given geometry.
+
+**geometryId**
+
+The ID of the geometry to return the bounding box for.
+
+**target**
+
+The target object that is used to store the method's result.
+
+**Returns:** The geometry's bounding box. Returns `null` if no geometry has been found for the given ID.
+
+### .getBoundingSphereAt( geometryId : number, target : Sphere ) : Sphere
+
+Returns the bounding sphere for the given geometry.
+
+**geometryId**
+
+The ID of the geometry to return the bounding sphere for.
+
+**target**
+
+The target object that is used to store the method's result.
+
+**Returns:** The geometry's bounding sphere. Returns `null` if no geometry has been found for the given ID.
+
+### .getColorAt( instanceId : number, color : Color ) : Color
+
+Returns the color of the defined instance.
+
+**instanceId**
+
+The ID of an instance to get the color of.
+
+**color**
+
+The target object that is used to store the method's result.
+
+**Returns:** The instance's color.
+
+### .getGeometryIdAt( instanceId : number ) : number
+
+Returns the geometry ID of the defined instance.
+
+**instanceId**
+
+The ID of an instance to get the geometry ID of.
+
+**Returns:** The instance's geometry ID.
+
+### .getGeometryRangeAt( geometryId : number, target : Object ) : Object
+
+Get the range representing the subset of triangles related to the attached geometry, indicating the starting offset and count, or `null` if invalid.
+
+**geometryId**
+
+The id of the geometry to get the range of.
+
+**target**
+
+The target object that is used to store the method's result.
+
+**Returns:** The result object with range data.
+
+### .getMatrixAt( instanceId : number, matrix : Matrix4 ) : Matrix4
+
+Returns the local transformation matrix of the defined instance.
+
+**instanceId**
+
+The ID of an instance to get the matrix of.
+
+**matrix**
+
+The target object that is used to store the method's result.
+
+**Returns:** The instance's local transformation matrix.
+
+### .getVisibleAt( instanceId : number ) : boolean
+
+Returns the visibility state of the defined instance.
+
+**instanceId**
+
+The ID of an instance to get the visibility state of.
+
+**Returns:** Whether the instance is visible or not.
+
+### .optimize() : BatchedMesh
+
+Repacks the sub geometries in BatchedMesh to remove any unused space remaining from previously deleted geometry, freeing up space to add new geometry.
+
+**Returns:** A reference to this batched mesh.
+
+### .setColorAt( instanceId : number, color : Color ) : BatchedMesh
+
+Sets the given color to the defined instance.
+
+**instanceId**
+
+The ID of an instance to set the color of.
+
+**color**
+
+The color to set the instance to.
+
+**Returns:** A reference to this batched mesh.
+
+### .setCustomSort( func : function ) : BatchedMesh
+
+Takes a sort a function that is run before render. The function takes a list of instances to sort and a camera. The objects in the list include a "z" field to perform a depth-ordered sort with.
+
+**func**
+
+The custom sort function.
+
+**Returns:** A reference to this batched mesh.
+
+### .setGeometryAt( geometryId : number, geometry : BufferGeometry ) : number
+
+Replaces the geometry at the given ID with the provided geometry. Throws an error if there is not enough space reserved for geometry. Calling this will change all instances that are rendering that geometry.
+
+**geometryId**
+
+The ID of the geometry that should be replaced with the given geometry.
+
+**geometry**
+
+The new geometry.
+
+**Returns:** The geometry ID.
+
+### .setGeometryIdAt( instanceId : number, geometryId : number ) : BatchedMesh
+
+Sets the geometry ID of the instance at the given index.
+
+**instanceId**
+
+The ID of the instance to set the geometry ID of.
+
+**geometryId**
+
+The geometry ID to be use by the instance.
+
+**Returns:** A reference to this batched mesh.
+
+### .setGeometrySize( maxVertexCount : number, maxIndexCount : number )
+
+Resizes the available space in the batch's vertex and index buffer attributes to the provided sizes. If the provided arguments shrink the geometry buffers but there is not enough unused space at the end of the geometry attributes then an error is thrown.
+
+**maxVertexCount**
+
+The maximum number of vertices to be used by all unique geometries to resize to.
+
+**maxIndexCount**
+
+The maximum number of indices to be used by all unique geometries to resize to.
+
+### .setInstanceCount( maxInstanceCount : number )
+
+Resizes the necessary buffers to support the provided number of instances. If the provided arguments shrink the number of instances but there are not enough unused Ids at the end of the list then an error is thrown.
+
+**maxInstanceCount**
+
+The max number of individual instances that can be added and rendered by the batch.
+
+### .setMatrixAt( instanceId : number, matrix : Matrix4 ) : BatchedMesh
+
+Sets the given local transformation matrix to the defined instance. Negatively scaled matrices are not supported.
+
+**instanceId**
+
+The ID of an instance to set the matrix of.
+
+**matrix**
+
+A 4x4 matrix representing the local transformation of a single instance.
+
+**Returns:** A reference to this batched mesh.
+
+### .setVisibleAt( instanceId : number, visible : boolean ) : BatchedMesh
+
+Sets the visibility of the instance.
+
+**instanceId**
+
+The id of the instance to set the visibility of.
+
+**visible**
+
+Whether the instance is visible or not.
+
+**Returns:** A reference to this batched mesh.
+
+### .validateGeometryId( geometryId : number )
+
+Validates the geometry defined by the given ID.
+
+**geometryId**
+
+The geometry to validate.
+
+### .validateInstanceId( instanceId : number )
+
+Validates the instance defined by the given ID.
+
+**instanceId**
+
+The instance to validate.
+
+## Source
+
+[src/objects/BatchedMesh.js](https://github.com/mrdoob/three.js/blob/master/src/objects/BatchedMesh.js)
\ No newline at end of file
diff --git a/docs/pages/BitcastNode.html.md b/docs/pages/BitcastNode.html.md
new file mode 100644
index 00000000000000..5a1c365b1419b7
--- /dev/null
+++ b/docs/pages/BitcastNode.html.md
@@ -0,0 +1,51 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# BitcastNode
+
+This node represents an operation that reinterprets the bit representation of a value in one type as a value in another type.
+
+## Constructor
+
+### new BitcastNode( valueNode : Node, conversionType : string, inputType : string )
+
+Constructs a new bitcast node.
+
+**valueNode**
+
+The value to convert.
+
+**conversionType**
+
+The type to convert to.
+
+**inputType**
+
+The expected input data type of the bitcast operation.
+
+Default is `null`.
+
+## Properties
+
+### .conversionType : string
+
+The type the value will be converted to.
+
+### .inputType : string
+
+The expected input data type of the bitcast operation.
+
+Default is `null`.
+
+### .isBitcastNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .valueNode : Node
+
+The data to bitcast to a new type.
+
+## Source
+
+[src/nodes/math/BitcastNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/math/BitcastNode.js)
\ No newline at end of file
diff --git a/docs/pages/BitcountNode.html.md b/docs/pages/BitcountNode.html.md
new file mode 100644
index 00000000000000..65d1b7db0afd8c
--- /dev/null
+++ b/docs/pages/BitcountNode.html.md
@@ -0,0 +1,31 @@
+*Inheritance: EventDispatcher → Node → TempNode → MathNode →*
+
+# BitcountNode
+
+This node represents an operation that counts the bits of a piece of shader data.
+
+## Constructor
+
+### new BitcountNode( method : 'countTrailingZeros' | 'countLeadingZeros' | 'countOneBits', aNode : Node )
+
+Constructs a new math node.
+
+**method**
+
+The method name.
+
+**aNode**
+
+The first input.
+
+## Properties
+
+### .isBitcountNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/nodes/math/BitcountNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/math/BitcountNode.js)
\ No newline at end of file
diff --git a/docs/pages/BitonicSort_BitonicSort.html.md b/docs/pages/BitonicSort_BitonicSort.html.md
new file mode 100644
index 00000000000000..0a86a70d4e2f8f
--- /dev/null
+++ b/docs/pages/BitonicSort_BitonicSort.html.md
@@ -0,0 +1,23 @@
+# BitonicSort
+
+### new BitonicSort( renderer : Renderer, dataBuffer : StorageBufferNode, options : Object )
+
+Constructs a new light probe helper.
+
+**renderer**
+
+The current scene's renderer.
+
+**dataBuffer**
+
+The data buffer to sort.
+
+**options**
+
+Options that modify the bitonic sort.
+
+Default is `{}`.
+
+## Source
+
+[examples/jsm/gpgpu/BitonicSort.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/gpgpu/BitonicSort.js)
\ No newline at end of file
diff --git a/docs/pages/BloomNode.html.md b/docs/pages/BloomNode.html.md
new file mode 100644
index 00000000000000..1fa7cfc9b28f0d
--- /dev/null
+++ b/docs/pages/BloomNode.html.md
@@ -0,0 +1,146 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# BloomNode
+
+Post processing node for creating a bloom effect.
+
+By default, the node affects the entire image. For a selective bloom, use the `emissive` material property to control which objects should contribute to bloom or not. This can be achieved via MRT.
+
+```js
+const postProcessing = new THREE.PostProcessing( renderer );
+const scenePass = pass( scene, camera );
+scenePass.setMRT( mrt( {
+ output,
+ emissive
+} ) );
+const scenePassColor = scenePass.getTextureNode( 'output' );
+const emissivePass = scenePass.getTextureNode( 'emissive' );
+const bloomPass = bloom( emissivePass );
+postProcessing.outputNode = scenePassColor.add( bloomPass );
+```
+
+## Code Example
+
+```js
+const postProcessing = new THREE.PostProcessing( renderer );
+const scenePass = pass( scene, camera );
+const scenePassColor = scenePass.getTextureNode( 'output' );
+const bloomPass = bloom( scenePassColor );
+postProcessing.outputNode = scenePassColor.add( bloomPass );
+```
+
+## Import
+
+BloomNode is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { bloom } from 'three/addons/tsl/display/BloomNode.js';
+```
+
+## Constructor
+
+### new BloomNode( inputNode : Node., strength : number, radius : number, threshold : number )
+
+Constructs a new bloom node.
+
+**inputNode**
+
+The node that represents the input of the effect.
+
+**strength**
+
+The strength of the bloom.
+
+Default is `1`.
+
+**radius**
+
+The radius of the bloom.
+
+Default is `0`.
+
+**threshold**
+
+The luminance threshold limits which bright areas contribute to the bloom effect.
+
+Default is `0`.
+
+## Properties
+
+### .inputNode : Node.
+
+The node that represents the input of the effect.
+
+### .radius : UniformNode.
+
+The radius of the bloom. Must be in the range `[0,1]`.
+
+### .smoothWidth : UniformNode.
+
+Can be used to tweak the extracted luminance from the scene.
+
+### .strength : UniformNode.
+
+The strength of the bloom.
+
+### .threshold : UniformNode.
+
+The luminance threshold limits which bright areas contribute to the bloom effect.
+
+### .updateBeforeType : string
+
+The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node renders its effect once per frame in `updateBefore()`.
+
+Default is `'frame'`.
+
+**Overrides:** [TempNode#updateBeforeType](TempNode.html#updateBeforeType)
+
+## Methods
+
+### .dispose()
+
+Frees internal resources. This method should be called when the effect is no longer required.
+
+**Overrides:** [TempNode#dispose](TempNode.html#dispose)
+
+### .getTextureNode() : PassTextureNode
+
+Returns the result of the effect as a texture node.
+
+**Returns:** A texture node that represents the result of the effect.
+
+### .setSize( width : number, height : number )
+
+Sets the size of the effect.
+
+**width**
+
+The width of the effect.
+
+**height**
+
+The height of the effect.
+
+### .setup( builder : NodeBuilder ) : PassTextureNode
+
+This method is used to setup the effect's TSL code.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#setup](TempNode.html#setup)
+
+### .updateBefore( frame : NodeFrame )
+
+This method is used to render the effect once per frame.
+
+**frame**
+
+The current node frame.
+
+**Overrides:** [TempNode#updateBefore](TempNode.html#updateBefore)
+
+## Source
+
+[examples/jsm/tsl/display/BloomNode.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/tsl/display/BloomNode.js)
\ No newline at end of file
diff --git a/docs/pages/BloomPass.html.md b/docs/pages/BloomPass.html.md
new file mode 100644
index 00000000000000..9f61fd67783ee8
--- /dev/null
+++ b/docs/pages/BloomPass.html.md
@@ -0,0 +1,124 @@
+*Inheritance: Pass →*
+
+# BloomPass
+
+A pass for a basic Bloom effect.
+
+[UnrealBloomPass](UnrealBloomPass.html) produces a more advanced Bloom but is also more expensive.
+
+## Code Example
+
+```js
+const effectBloom = new BloomPass( 0.75 );
+composer.addPass( effectBloom );
+```
+
+## Import
+
+BloomPass is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { BloomPass } from 'three/addons/postprocessing/BloomPass.js';
+```
+
+## Constructor
+
+### new BloomPass( strength : number, kernelSize : number, sigma : number )
+
+Constructs a new Bloom pass.
+
+**strength**
+
+The Bloom strength.
+
+Default is `1`.
+
+**kernelSize**
+
+The kernel size.
+
+Default is `25`.
+
+**sigma**
+
+The sigma.
+
+Default is `4`.
+
+## Properties
+
+### .combineUniforms : Object
+
+The combine pass uniforms.
+
+### .convolutionUniforms : Object
+
+The convolution pass uniforms.
+
+### .materialCombine : ShaderMaterial
+
+The combine pass material.
+
+### .materialConvolution : ShaderMaterial
+
+The convolution pass material.
+
+### .needsSwap : boolean
+
+Overwritten to disable the swap.
+
+Default is `false`.
+
+**Overrides:** [Pass#needsSwap](Pass.html#needsSwap)
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever the pass is no longer used in your app.
+
+**Overrides:** [Pass#dispose](Pass.html#dispose)
+
+### .render( renderer : WebGLRenderer, writeBuffer : WebGLRenderTarget, readBuffer : WebGLRenderTarget, deltaTime : number, maskActive : boolean )
+
+Performs the Bloom pass.
+
+**renderer**
+
+The renderer.
+
+**writeBuffer**
+
+The write buffer. This buffer is intended as the rendering destination for the pass.
+
+**readBuffer**
+
+The read buffer. The pass can access the result from the previous pass from this buffer.
+
+**deltaTime**
+
+The delta time in seconds.
+
+**maskActive**
+
+Whether masking is active or not.
+
+**Overrides:** [Pass#render](Pass.html#render)
+
+### .setSize( width : number, height : number )
+
+Sets the size of the pass.
+
+**width**
+
+The width to set.
+
+**height**
+
+The height to set.
+
+**Overrides:** [Pass#setSize](Pass.html#setSize)
+
+## Source
+
+[examples/jsm/postprocessing/BloomPass.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/BloomPass.js)
\ No newline at end of file
diff --git a/docs/pages/BokehPass.html.md b/docs/pages/BokehPass.html.md
new file mode 100644
index 00000000000000..fac33728468fad
--- /dev/null
+++ b/docs/pages/BokehPass.html.md
@@ -0,0 +1,145 @@
+*Inheritance: Pass →*
+
+# BokehPass
+
+Pass for creating depth of field (DOF) effect.
+
+## Code Example
+
+```js
+const bokehPass = new BokehPass( scene, camera, {
+ focus: 500
+ aperture: 5,
+ maxblur: 0.01
+} );
+composer.addPass( bokehPass );
+```
+
+## Import
+
+BokehPass is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { BokehPass } from 'three/addons/postprocessing/BokehPass.js';
+```
+
+## Constructor
+
+### new BokehPass( scene : Scene, camera : Camera, params : BokehPass~Options )
+
+Constructs a new Bokeh pass.
+
+**scene**
+
+The scene to render the DOF for.
+
+**camera**
+
+The camera.
+
+**params**
+
+The pass options.
+
+## Properties
+
+### .camera : Camera
+
+The camera.
+
+### .materialBokeh : ShaderMaterial
+
+The pass bokeh material.
+
+### .scene : Scene
+
+The scene to render the DOF for.
+
+### .uniforms : Object
+
+The pass uniforms. Use this object if you want to update the `focus`, `aperture` or `maxblur` values at runtime.
+
+```js
+pass.uniforms.focus.value = focus;
+pass.uniforms.aperture.value = aperture;
+pass.uniforms.maxblur.value = maxblur;
+```
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever the pass is no longer used in your app.
+
+**Overrides:** [Pass#dispose](Pass.html#dispose)
+
+### .render( renderer : WebGLRenderer, writeBuffer : WebGLRenderTarget, readBuffer : WebGLRenderTarget, deltaTime : number, maskActive : boolean )
+
+Performs the Bokeh pass.
+
+**renderer**
+
+The renderer.
+
+**writeBuffer**
+
+The write buffer. This buffer is intended as the rendering destination for the pass.
+
+**readBuffer**
+
+The read buffer. The pass can access the result from the previous pass from this buffer.
+
+**deltaTime**
+
+The delta time in seconds.
+
+**maskActive**
+
+Whether masking is active or not.
+
+**Overrides:** [Pass#render](Pass.html#render)
+
+### .setSize( width : number, height : number )
+
+Sets the size of the pass.
+
+**width**
+
+The width to set.
+
+**height**
+
+The height to set.
+
+**Overrides:** [Pass#setSize](Pass.html#setSize)
+
+## Type Definitions
+
+### .Options
+
+Constructor options of `BokehPass`.
+
+**focus**
+number
+
+Defines the effect's focus which is the distance along the camera's look direction in world units.
+
+Default is `1`.
+
+**aperture**
+number
+
+Defines the effect's aperture.
+
+Default is `0.025`.
+
+**maxblur**
+number
+
+Defines the effect's maximum blur.
+
+Default is `1`.
+
+## Source
+
+[examples/jsm/postprocessing/BokehPass.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/BokehPass.js)
\ No newline at end of file
diff --git a/docs/pages/Bone.html.md b/docs/pages/Bone.html.md
new file mode 100644
index 00000000000000..2e1b0f180179b9
--- /dev/null
+++ b/docs/pages/Bone.html.md
@@ -0,0 +1,32 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# Bone
+
+A bone which is part of a [Skeleton](Skeleton.html). The skeleton in turn is used by the [SkinnedMesh](SkinnedMesh.html).
+
+## Code Example
+
+```js
+const root = new THREE.Bone();
+const child = new THREE.Bone();
+root.add( child );
+child.position.y = 5;
+```
+
+## Constructor
+
+### new Bone()
+
+Constructs a new bone.
+
+## Properties
+
+### .isBone : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/objects/Bone.js](https://github.com/mrdoob/three.js/blob/master/src/objects/Bone.js)
\ No newline at end of file
diff --git a/docs/pages/BooleanKeyframeTrack.html.md b/docs/pages/BooleanKeyframeTrack.html.md
new file mode 100644
index 00000000000000..60ef85cf1828bb
--- /dev/null
+++ b/docs/pages/BooleanKeyframeTrack.html.md
@@ -0,0 +1,55 @@
+*Inheritance: KeyframeTrack →*
+
+# BooleanKeyframeTrack
+
+A track for boolean keyframe values.
+
+## Constructor
+
+### new BooleanKeyframeTrack( name : string, times : Array., values : Array. )
+
+Constructs a new boolean keyframe track.
+
+This keyframe track type has no `interpolation` parameter because the interpolation is always discrete.
+
+**name**
+
+The keyframe track's name.
+
+**times**
+
+A list of keyframe times.
+
+**values**
+
+A list of keyframe values.
+
+## Properties
+
+### .DefaultInterpolation : InterpolateLinear | InterpolateDiscrete | InterpolateSmooth
+
+The default interpolation type of this keyframe track.
+
+Default is `InterpolateDiscrete`.
+
+**Overrides:** [KeyframeTrack#DefaultInterpolation](KeyframeTrack.html#DefaultInterpolation)
+
+### .ValueBufferType : TypedArray | Array
+
+The value buffer type of this keyframe track.
+
+Default is `Array.constructor`.
+
+**Overrides:** [KeyframeTrack#ValueBufferType](KeyframeTrack.html#ValueBufferType)
+
+### .ValueTypeName : string
+
+The value type name.
+
+Default is `'bool'`.
+
+**Overrides:** [KeyframeTrack#ValueTypeName](KeyframeTrack.html#ValueTypeName)
+
+## Source
+
+[src/animation/tracks/BooleanKeyframeTrack.js](https://github.com/mrdoob/three.js/blob/master/src/animation/tracks/BooleanKeyframeTrack.js)
\ No newline at end of file
diff --git a/docs/pages/Box2.html.md b/docs/pages/Box2.html.md
new file mode 100644
index 00000000000000..f50135f2ddddd3
--- /dev/null
+++ b/docs/pages/Box2.html.md
@@ -0,0 +1,267 @@
+# Box2
+
+Represents an axis-aligned bounding box (AABB) in 2D space.
+
+## Constructor
+
+### new Box2( min : Vector2, max : Vector2 )
+
+Constructs a new bounding box.
+
+**min**
+
+A vector representing the lower boundary of the box.
+
+Default is `(Infinity,Infinity)`.
+
+**max**
+
+A vector representing the upper boundary of the box.
+
+Default is `(-Infinity,-Infinity)`.
+
+## Properties
+
+### .isBox2 : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .max : Vector2
+
+The upper boundary of the box.
+
+### .min : Vector2
+
+The lower boundary of the box.
+
+## Methods
+
+### .clampPoint( point : Vector2, target : Vector2 ) : Vector2
+
+Clamps the given point within the bounds of this box.
+
+**point**
+
+The point to clamp.
+
+**target**
+
+The target vector that is used to store the method's result.
+
+**Returns:** The clamped point.
+
+### .clone() : Box2
+
+Returns a new box with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .containsBox( box : Box2 ) : boolean
+
+Returns `true` if this bounding box includes the entirety of the given bounding box. If this box and the given one are identical, this function also returns `true`.
+
+**box**
+
+The bounding box to test.
+
+**Returns:** Whether the bounding box contains the given bounding box or not.
+
+### .containsPoint( point : Vector2 ) : boolean
+
+Returns `true` if the given point lies within or on the boundaries of this box.
+
+**point**
+
+The point to test.
+
+**Returns:** Whether the bounding box contains the given point or not.
+
+### .copy( box : Box2 ) : Box2
+
+Copies the values of the given box to this instance.
+
+**box**
+
+The box to copy.
+
+**Returns:** A reference to this bounding box.
+
+### .distanceToPoint( point : Vector2 ) : number
+
+Returns the euclidean distance from any edge of this box to the specified point. If the given point lies inside of this box, the distance will be `0`.
+
+**point**
+
+The point to compute the distance to.
+
+**Returns:** The euclidean distance.
+
+### .equals( box : Box2 ) : boolean
+
+Returns `true` if this bounding box is equal with the given one.
+
+**box**
+
+The box to test for equality.
+
+**Returns:** Whether this bounding box is equal with the given one.
+
+### .expandByPoint( point : Vector2 ) : Box2
+
+Expands the boundaries of this box to include the given point.
+
+**point**
+
+The point that should be included by the bounding box.
+
+**Returns:** A reference to this bounding box.
+
+### .expandByScalar( scalar : number ) : Box2
+
+Expands each dimension of the box by the given scalar. If negative, the dimensions of the box will be contracted.
+
+**scalar**
+
+The scalar value that should expand the bounding box.
+
+**Returns:** A reference to this bounding box.
+
+### .expandByVector( vector : Vector2 ) : Box2
+
+Expands this box equilaterally by the given vector. The width of this box will be expanded by the x component of the vector in both directions. The height of this box will be expanded by the y component of the vector in both directions.
+
+**vector**
+
+The vector that should expand the bounding box.
+
+**Returns:** A reference to this bounding box.
+
+### .getCenter( target : Vector2 ) : Vector2
+
+Returns the center point of this box.
+
+**target**
+
+The target vector that is used to store the method's result.
+
+**Returns:** The center point.
+
+### .getParameter( point : Vector2, target : Vector2 ) : Vector2
+
+Returns a point as a proportion of this box's width and height.
+
+**point**
+
+A point in 2D space.
+
+**target**
+
+The target vector that is used to store the method's result.
+
+**Returns:** A point as a proportion of this box's width and height.
+
+### .getSize( target : Vector2 ) : Vector2
+
+Returns the dimensions of this box.
+
+**target**
+
+The target vector that is used to store the method's result.
+
+**Returns:** The size.
+
+### .intersect( box : Box2 ) : Box2
+
+Computes the intersection of this bounding box and the given one, setting the upper bound of this box to the lesser of the two boxes' upper bounds and the lower bound of this box to the greater of the two boxes' lower bounds. If there's no overlap, makes this box empty.
+
+**box**
+
+The bounding box to intersect with.
+
+**Returns:** A reference to this bounding box.
+
+### .intersectsBox( box : Box2 ) : boolean
+
+Returns `true` if the given bounding box intersects with this bounding box.
+
+**box**
+
+The bounding box to test.
+
+**Returns:** Whether the given bounding box intersects with this bounding box.
+
+### .isEmpty() : boolean
+
+Returns true if this box includes zero points within its bounds. Note that a box with equal lower and upper bounds still includes one point, the one both bounds share.
+
+**Returns:** Whether this box is empty or not.
+
+### .makeEmpty() : Box2
+
+Makes this box empty which means in encloses a zero space in 2D.
+
+**Returns:** A reference to this bounding box.
+
+### .set( min : Vector2, max : Vector2 ) : Box2
+
+Sets the lower and upper boundaries of this box. Please note that this method only copies the values from the given objects.
+
+**min**
+
+The lower boundary of the box.
+
+**max**
+
+The upper boundary of the box.
+
+**Returns:** A reference to this bounding box.
+
+### .setFromCenterAndSize( center : Vector2, size : Vector2 ) : Box2
+
+Centers this box on the given center vector and sets this box's width, height and depth to the given size values.
+
+**center**
+
+The center of the box.
+
+**size**
+
+The x and y dimensions of the box.
+
+**Returns:** A reference to this bounding box.
+
+### .setFromPoints( points : Array. ) : Box2
+
+Sets the upper and lower bounds of this box so it encloses the position data in the given array.
+
+**points**
+
+An array holding 2D position data as instances of [Vector2](Vector2.html).
+
+**Returns:** A reference to this bounding box.
+
+### .translate( offset : Vector2 ) : Box2
+
+Adds the given offset to both the upper and lower bounds of this bounding box, effectively moving it in 2D space.
+
+**offset**
+
+The offset that should be used to translate the bounding box.
+
+**Returns:** A reference to this bounding box.
+
+### .union( box : Box2 ) : Box2
+
+Computes the union of this box and another and the given one, setting the upper bound of this box to the greater of the two boxes' upper bounds and the lower bound of this box to the lesser of the two boxes' lower bounds.
+
+**box**
+
+The bounding box that will be unioned with this instance.
+
+**Returns:** A reference to this bounding box.
+
+## Source
+
+[src/math/Box2.js](https://github.com/mrdoob/three.js/blob/master/src/math/Box2.js)
\ No newline at end of file
diff --git a/docs/pages/Box3.html.md b/docs/pages/Box3.html.md
new file mode 100644
index 00000000000000..c69e04cb22c25f
--- /dev/null
+++ b/docs/pages/Box3.html.md
@@ -0,0 +1,385 @@
+# Box3
+
+Represents an axis-aligned bounding box (AABB) in 3D space.
+
+## Constructor
+
+### new Box3( min : Vector3, max : Vector3 )
+
+Constructs a new bounding box.
+
+**min**
+
+A vector representing the lower boundary of the box.
+
+Default is `(Infinity,Infinity,Infinity)`.
+
+**max**
+
+A vector representing the upper boundary of the box.
+
+Default is `(-Infinity,-Infinity,-Infinity)`.
+
+## Properties
+
+### .isBox3 : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .max : Vector3
+
+The upper boundary of the box.
+
+### .min : Vector3
+
+The lower boundary of the box.
+
+## Methods
+
+### .applyMatrix4( matrix : Matrix4 ) : Box3
+
+Transforms this bounding box by the given 4x4 transformation matrix.
+
+**matrix**
+
+The transformation matrix.
+
+**Returns:** A reference to this bounding box.
+
+### .clampPoint( point : Vector3, target : Vector3 ) : Vector3
+
+Clamps the given point within the bounds of this box.
+
+**point**
+
+The point to clamp.
+
+**target**
+
+The target vector that is used to store the method's result.
+
+**Returns:** The clamped point.
+
+### .clone() : Box3
+
+Returns a new box with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .containsBox( box : Box3 ) : boolean
+
+Returns `true` if this bounding box includes the entirety of the given bounding box. If this box and the given one are identical, this function also returns `true`.
+
+**box**
+
+The bounding box to test.
+
+**Returns:** Whether the bounding box contains the given bounding box or not.
+
+### .containsPoint( point : Vector3 ) : boolean
+
+Returns `true` if the given point lies within or on the boundaries of this box.
+
+**point**
+
+The point to test.
+
+**Returns:** Whether the bounding box contains the given point or not.
+
+### .copy( box : Box3 ) : Box3
+
+Copies the values of the given box to this instance.
+
+**box**
+
+The box to copy.
+
+**Returns:** A reference to this bounding box.
+
+### .distanceToPoint( point : Vector3 ) : number
+
+Returns the euclidean distance from any edge of this box to the specified point. If the given point lies inside of this box, the distance will be `0`.
+
+**point**
+
+The point to compute the distance to.
+
+**Returns:** The euclidean distance.
+
+### .equals( box : Box3 ) : boolean
+
+Returns `true` if this bounding box is equal with the given one.
+
+**box**
+
+The box to test for equality.
+
+**Returns:** Whether this bounding box is equal with the given one.
+
+### .expandByObject( object : Object3D, precise : boolean ) : Box3
+
+Expands the boundaries of this box to include the given 3D object and its children, accounting for the object's, and children's, world transforms. The function may result in a larger box than strictly necessary (unless the precise parameter is set to true).
+
+**object**
+
+The 3D object that should expand the bounding box.
+
+**precise**
+
+If set to `true`, the method expands the bounding box as little as necessary at the expense of more computation.
+
+Default is `false`.
+
+**Returns:** A reference to this bounding box.
+
+### .expandByPoint( point : Vector3 ) : Box3
+
+Expands the boundaries of this box to include the given point.
+
+**point**
+
+The point that should be included by the bounding box.
+
+**Returns:** A reference to this bounding box.
+
+### .expandByScalar( scalar : number ) : Box3
+
+Expands each dimension of the box by the given scalar. If negative, the dimensions of the box will be contracted.
+
+**scalar**
+
+The scalar value that should expand the bounding box.
+
+**Returns:** A reference to this bounding box.
+
+### .expandByVector( vector : Vector3 ) : Box3
+
+Expands this box equilaterally by the given vector. The width of this box will be expanded by the x component of the vector in both directions. The height of this box will be expanded by the y component of the vector in both directions. The depth of this box will be expanded by the z component of the vector in both directions.
+
+**vector**
+
+The vector that should expand the bounding box.
+
+**Returns:** A reference to this bounding box.
+
+### .fromJSON( json : Object ) : Box3
+
+Returns a serialized structure of the bounding box.
+
+**json**
+
+The serialized json to set the box from.
+
+**Returns:** A reference to this bounding box.
+
+### .getBoundingSphere( target : Sphere ) : Sphere
+
+Returns a bounding sphere that encloses this bounding box.
+
+**target**
+
+The target sphere that is used to store the method's result.
+
+**Returns:** The bounding sphere that encloses this bounding box.
+
+### .getCenter( target : Vector3 ) : Vector3
+
+Returns the center point of this box.
+
+**target**
+
+The target vector that is used to store the method's result.
+
+**Returns:** The center point.
+
+### .getParameter( point : Vector3, target : Vector3 ) : Vector3
+
+Returns a point as a proportion of this box's width, height and depth.
+
+**point**
+
+A point in 3D space.
+
+**target**
+
+The target vector that is used to store the method's result.
+
+**Returns:** A point as a proportion of this box's width, height and depth.
+
+### .getSize( target : Vector3 ) : Vector3
+
+Returns the dimensions of this box.
+
+**target**
+
+The target vector that is used to store the method's result.
+
+**Returns:** The size.
+
+### .intersect( box : Box3 ) : Box3
+
+Computes the intersection of this bounding box and the given one, setting the upper bound of this box to the lesser of the two boxes' upper bounds and the lower bound of this box to the greater of the two boxes' lower bounds. If there's no overlap, makes this box empty.
+
+**box**
+
+The bounding box to intersect with.
+
+**Returns:** A reference to this bounding box.
+
+### .intersectsBox( box : Box3 ) : boolean
+
+Returns `true` if the given bounding box intersects with this bounding box.
+
+**box**
+
+The bounding box to test.
+
+**Returns:** Whether the given bounding box intersects with this bounding box.
+
+### .intersectsPlane( plane : Plane ) : boolean
+
+Returns `true` if the given plane intersects with this bounding box.
+
+**plane**
+
+The plane to test.
+
+**Returns:** Whether the given plane intersects with this bounding box.
+
+### .intersectsSphere( sphere : Sphere ) : boolean
+
+Returns `true` if the given bounding sphere intersects with this bounding box.
+
+**sphere**
+
+The bounding sphere to test.
+
+**Returns:** Whether the given bounding sphere intersects with this bounding box.
+
+### .intersectsTriangle( triangle : Triangle ) : boolean
+
+Returns `true` if the given triangle intersects with this bounding box.
+
+**triangle**
+
+The triangle to test.
+
+**Returns:** Whether the given triangle intersects with this bounding box.
+
+### .isEmpty() : boolean
+
+Returns true if this box includes zero points within its bounds. Note that a box with equal lower and upper bounds still includes one point, the one both bounds share.
+
+**Returns:** Whether this box is empty or not.
+
+### .makeEmpty() : Box3
+
+Makes this box empty which means in encloses a zero space in 3D.
+
+**Returns:** A reference to this bounding box.
+
+### .set( min : Vector3, max : Vector3 ) : Box3
+
+Sets the lower and upper boundaries of this box. Please note that this method only copies the values from the given objects.
+
+**min**
+
+The lower boundary of the box.
+
+**max**
+
+The upper boundary of the box.
+
+**Returns:** A reference to this bounding box.
+
+### .setFromArray( array : Array. ) : Box3
+
+Sets the upper and lower bounds of this box so it encloses the position data in the given array.
+
+**array**
+
+An array holding 3D position data.
+
+**Returns:** A reference to this bounding box.
+
+### .setFromBufferAttribute( attribute : BufferAttribute ) : Box3
+
+Sets the upper and lower bounds of this box so it encloses the position data in the given buffer attribute.
+
+**attribute**
+
+A buffer attribute holding 3D position data.
+
+**Returns:** A reference to this bounding box.
+
+### .setFromCenterAndSize( center : Vector3, size : Vector3 ) : Box3
+
+Centers this box on the given center vector and sets this box's width, height and depth to the given size values.
+
+**center**
+
+The center of the box.
+
+**size**
+
+The x, y and z dimensions of the box.
+
+**Returns:** A reference to this bounding box.
+
+### .setFromObject( object : Object3D, precise : boolean ) : Box3
+
+Computes the world-axis-aligned bounding box for the given 3D object (including its children), accounting for the object's, and children's, world transforms. The function may result in a larger box than strictly necessary.
+
+**object**
+
+The 3D object to compute the bounding box for.
+
+**precise**
+
+If set to `true`, the method computes the smallest world-axis-aligned bounding box at the expense of more computation.
+
+Default is `false`.
+
+**Returns:** A reference to this bounding box.
+
+### .setFromPoints( points : Array. ) : Box3
+
+Sets the upper and lower bounds of this box so it encloses the position data in the given array.
+
+**points**
+
+An array holding 3D position data as instances of [Vector3](Vector3.html).
+
+**Returns:** A reference to this bounding box.
+
+### .toJSON() : Object
+
+Returns a serialized structure of the bounding box.
+
+**Returns:** Serialized structure with fields representing the object state.
+
+### .translate( offset : Vector3 ) : Box3
+
+Adds the given offset to both the upper and lower bounds of this bounding box, effectively moving it in 3D space.
+
+**offset**
+
+The offset that should be used to translate the bounding box.
+
+**Returns:** A reference to this bounding box.
+
+### .union( box : Box3 ) : Box3
+
+Computes the union of this box and another and the given one, setting the upper bound of this box to the greater of the two boxes' upper bounds and the lower bound of this box to the lesser of the two boxes' lower bounds.
+
+**box**
+
+The bounding box that will be unioned with this instance.
+
+**Returns:** A reference to this bounding box.
+
+## Source
+
+[src/math/Box3.js](https://github.com/mrdoob/three.js/blob/master/src/math/Box3.js)
\ No newline at end of file
diff --git a/docs/pages/Box3Helper.html.md b/docs/pages/Box3Helper.html.md
new file mode 100644
index 00000000000000..f589fd23b73350
--- /dev/null
+++ b/docs/pages/Box3Helper.html.md
@@ -0,0 +1,46 @@
+*Inheritance: EventDispatcher → Object3D → Line → LineSegments →*
+
+# Box3Helper
+
+A helper object to visualize an instance of [Box3](Box3.html).
+
+## Code Example
+
+```js
+const box = new THREE.Box3();
+box.setFromCenterAndSize( new THREE.Vector3( 1, 1, 1 ), new THREE.Vector3( 2, 1, 3 ) );
+const helper = new THREE.Box3Helper( box, 0xffff00 );
+scene.add( helper )
+```
+
+## Constructor
+
+### new Box3Helper( box : Box3, color : number | Color | string )
+
+Constructs a new box3 helper.
+
+**box**
+
+The box to visualize.
+
+**color**
+
+The box's color.
+
+Default is `0xffff00`.
+
+## Properties
+
+### .box : Box3
+
+The box being visualized.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+## Source
+
+[src/helpers/Box3Helper.js](https://github.com/mrdoob/three.js/blob/master/src/helpers/Box3Helper.js)
\ No newline at end of file
diff --git a/docs/pages/BoxGeometry.html.md b/docs/pages/BoxGeometry.html.md
new file mode 100644
index 00000000000000..e3ea836c048019
--- /dev/null
+++ b/docs/pages/BoxGeometry.html.md
@@ -0,0 +1,78 @@
+*Inheritance: EventDispatcher → BufferGeometry →*
+
+# BoxGeometry
+
+A geometry class for a rectangular cuboid with a given width, height, and depth. On creation, the cuboid is centred on the origin, with each edge parallel to one of the axes.
+
+## Code Example
+
+```js
+const geometry = new THREE.BoxGeometry( 1, 1, 1 );
+const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
+const cube = new THREE.Mesh( geometry, material );
+scene.add( cube );
+```
+
+## Constructor
+
+### new BoxGeometry( width : number, height : number, depth : number, widthSegments : number, heightSegments : number, depthSegments : number )
+
+Constructs a new box geometry.
+
+**width**
+
+The width. That is, the length of the edges parallel to the X axis.
+
+Default is `1`.
+
+**height**
+
+The height. That is, the length of the edges parallel to the Y axis.
+
+Default is `1`.
+
+**depth**
+
+The depth. That is, the length of the edges parallel to the Z axis.
+
+Default is `1`.
+
+**widthSegments**
+
+Number of segmented rectangular faces along the width of the sides.
+
+Default is `1`.
+
+**heightSegments**
+
+Number of segmented rectangular faces along the height of the sides.
+
+Default is `1`.
+
+**depthSegments**
+
+Number of segmented rectangular faces along the depth of the sides.
+
+Default is `1`.
+
+## Properties
+
+### .parameters : Object
+
+Holds the constructor parameters that have been used to generate the geometry. Any modification after instantiation does not change the geometry.
+
+## Static Methods
+
+### .fromJSON( data : Object ) : BoxGeometry
+
+Factory method for creating an instance of this class from the given JSON object.
+
+**data**
+
+A JSON object representing the serialized geometry.
+
+**Returns:** A new instance.
+
+## Source
+
+[src/geometries/BoxGeometry.js](https://github.com/mrdoob/three.js/blob/master/src/geometries/BoxGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/BoxHelper.html.md b/docs/pages/BoxHelper.html.md
new file mode 100644
index 00000000000000..1d9267fe06a422
--- /dev/null
+++ b/docs/pages/BoxHelper.html.md
@@ -0,0 +1,60 @@
+*Inheritance: EventDispatcher → Object3D → Line → LineSegments →*
+
+# BoxHelper
+
+Helper object to graphically show the world-axis-aligned bounding box around an object. The actual bounding box is handled with [Box3](Box3.html), this is just a visual helper for debugging. It can be automatically resized with [BoxHelper#update](BoxHelper.html#update) when the object it's created from is transformed. Note that the object must have a geometry for this to work, so it won't work with sprites.
+
+## Code Example
+
+```js
+const sphere = new THREE.SphereGeometry();
+const object = new THREE.Mesh( sphere, new THREE.MeshBasicMaterial( 0xff0000 ) );
+const box = new THREE.BoxHelper( object, 0xffff00 );
+scene.add( box );
+```
+
+## Constructor
+
+### new BoxHelper( object : Object3D, color : number | Color | string )
+
+Constructs a new box helper.
+
+**object**
+
+The 3D object to show the world-axis-aligned bounding box.
+
+**color**
+
+The box's color.
+
+Default is `0xffff00`.
+
+## Properties
+
+### .object : Object3D
+
+The 3D object being visualized.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+### .setFromObject( object : Object3D ) : BoxHelper
+
+Updates the wireframe box for the passed object.
+
+**object**
+
+The 3D object to create the helper for.
+
+**Returns:** A reference to this instance.
+
+### .update()
+
+Updates the helper's geometry to match the dimensions of the object, including any children.
+
+## Source
+
+[src/helpers/BoxHelper.js](https://github.com/mrdoob/three.js/blob/master/src/helpers/BoxHelper.js)
\ No newline at end of file
diff --git a/docs/pages/BoxLineGeometry.html.md b/docs/pages/BoxLineGeometry.html.md
new file mode 100644
index 00000000000000..beef9828182989
--- /dev/null
+++ b/docs/pages/BoxLineGeometry.html.md
@@ -0,0 +1,68 @@
+*Inheritance: EventDispatcher → BufferGeometry →*
+
+# BoxLineGeometry
+
+A special type of box geometry intended for [LineSegments](LineSegments.html).
+
+## Code Example
+
+```js
+const geometry = new THREE.BoxLineGeometry();
+const material = new THREE.LineBasicMaterial( { color: 0x00ff00 } );
+const lines = new THREE.LineSegments( geometry, material );
+scene.add( lines );
+```
+
+## Import
+
+BoxLineGeometry is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { BoxLineGeometry } from 'three/addons/geometries/BoxLineGeometry.js';
+```
+
+## Constructor
+
+### new BoxLineGeometry( width : number, height : number, depth : number, widthSegments : number, heightSegments : number, depthSegments : number )
+
+Constructs a new box line geometry.
+
+**width**
+
+The width. That is, the length of the edges parallel to the X axis.
+
+Default is `1`.
+
+**height**
+
+The height. That is, the length of the edges parallel to the Y axis.
+
+Default is `1`.
+
+**depth**
+
+The depth. That is, the length of the edges parallel to the Z axis.
+
+Default is `1`.
+
+**widthSegments**
+
+Number of segmented rectangular sections along the width of the sides.
+
+Default is `1`.
+
+**heightSegments**
+
+Number of segmented rectangular sections along the height of the sides.
+
+Default is `1`.
+
+**depthSegments**
+
+Number of segmented rectangular sections along the depth of the sides.
+
+Default is `1`.
+
+## Source
+
+[examples/jsm/geometries/BoxLineGeometry.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/geometries/BoxLineGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/BufferAttribute.html.md b/docs/pages/BufferAttribute.html.md
new file mode 100644
index 00000000000000..e3378fb7457d08
--- /dev/null
+++ b/docs/pages/BufferAttribute.html.md
@@ -0,0 +1,433 @@
+# BufferAttribute
+
+This class stores data for an attribute (such as vertex positions, face indices, normals, colors, UVs, and any custom attributes ) associated with a geometry, which allows for more efficient passing of data to the GPU.
+
+When working with vector-like data, the `fromBufferAttribute( attribute, index )` helper methods on vector and color class might be helpful. E.g. [Vector3#fromBufferAttribute](Vector3.html#fromBufferAttribute).
+
+## Constructor
+
+### new BufferAttribute( array : TypedArray, itemSize : number, normalized : boolean )
+
+Constructs a new buffer attribute.
+
+**array**
+
+The array holding the attribute data.
+
+**itemSize**
+
+The item size.
+
+**normalized**
+
+Whether the data are normalized or not.
+
+Default is `false`.
+
+## Properties
+
+### .array : TypedArray
+
+The array holding the attribute data. It should have `itemSize * numVertices` elements, where `numVertices` is the number of vertices in the associated geometry.
+
+### .count : number (readonly)
+
+Represents the number of items this buffer attribute stores. It is internally computed by dividing the `array` length by the `itemSize`.
+
+### .gpuType : FloatType | IntType
+
+Configures the bound GPU type for use in shaders.
+
+Note: this only has an effect for integer arrays and is not configurable for float arrays. For lower precision float types, use `Float16BufferAttribute`.
+
+Default is `FloatType`.
+
+### .id : number (readonly)
+
+The ID of the buffer attribute.
+
+### .isBufferAttribute : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .itemSize : number
+
+The number of values of the array that should be associated with a particular vertex. For instance, if this attribute is storing a 3-component vector (such as a position, normal, or color), then the value should be `3`.
+
+### .name : string
+
+The name of the buffer attribute.
+
+### .needsUpdate : number
+
+Flag to indicate that this attribute has changed and should be re-sent to the GPU. Set this to `true` when you modify the value of the array.
+
+Default is `false`.
+
+### .normalized : boolean
+
+Applies to integer data only. Indicates how the underlying data in the buffer maps to the values in the GLSL code. For instance, if `array` is an instance of `UInt16Array`, and `normalized` is `true`, the values `0 - +65535` in the array data will be mapped to `0.0f - +1.0f` in the GLSL attribute. If `normalized` is `false`, the values will be converted to floats unmodified, i.e. `65535` becomes `65535.0f`.
+
+### .updateRanges : Array.
+
+This can be used to only update some components of stored vectors (for example, just the component related to color). Use the `addUpdateRange()` function to add ranges to this array.
+
+### .usage : StaticDrawUsage | DynamicDrawUsage | StreamDrawUsage | StaticReadUsage | DynamicReadUsage | StreamReadUsage | StaticCopyUsage | DynamicCopyUsage | StreamCopyUsage
+
+Defines the intended usage pattern of the data store for optimization purposes.
+
+Note: After the initial use of a buffer, its usage cannot be changed. Instead, instantiate a new one and set the desired usage before the next render.
+
+Default is `StaticDrawUsage`.
+
+### .version : number
+
+A version number, incremented every time the `needsUpdate` is set to `true`.
+
+## Methods
+
+### .addUpdateRange( start : number, count : number )
+
+Adds a range of data in the data array to be updated on the GPU.
+
+**start**
+
+Position at which to start update.
+
+**count**
+
+The number of components to update.
+
+### .applyMatrix3( m : Matrix3 ) : BufferAttribute
+
+Applies the given 3x3 matrix to the given attribute. Works with item size `2` and `3`.
+
+**m**
+
+The matrix to apply.
+
+**Returns:** A reference to this instance.
+
+### .applyMatrix4( m : Matrix4 ) : BufferAttribute
+
+Applies the given 4x4 matrix to the given attribute. Only works with item size `3`.
+
+**m**
+
+The matrix to apply.
+
+**Returns:** A reference to this instance.
+
+### .applyNormalMatrix( m : Matrix3 ) : BufferAttribute
+
+Applies the given 3x3 normal matrix to the given attribute. Only works with item size `3`.
+
+**m**
+
+The normal matrix to apply.
+
+**Returns:** A reference to this instance.
+
+### .clearUpdateRanges()
+
+Clears the update ranges.
+
+### .clone() : BufferAttribute
+
+Returns a new buffer attribute with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .copy( source : BufferAttribute ) : BufferAttribute
+
+Copies the values of the given buffer attribute to this instance.
+
+**source**
+
+The buffer attribute to copy.
+
+**Returns:** A reference to this instance.
+
+### .copyArray( array : TypedArray | Array ) : BufferAttribute
+
+Copies the given array data into this buffer attribute.
+
+**array**
+
+The array to copy.
+
+**Returns:** A reference to this instance.
+
+### .copyAt( index1 : number, attribute : BufferAttribute, index2 : number ) : BufferAttribute
+
+Copies a vector from the given buffer attribute to this one. The start and destination position in the attribute buffers are represented by the given indices.
+
+**index1**
+
+The destination index into this buffer attribute.
+
+**attribute**
+
+The buffer attribute to copy from.
+
+**index2**
+
+The source index into the given buffer attribute.
+
+**Returns:** A reference to this instance.
+
+### .getComponent( index : number, component : number ) : number
+
+Returns the given component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**component**
+
+The component index.
+
+**Returns:** The returned value.
+
+### .getW( index : number ) : number
+
+Returns the w component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**Returns:** The w component.
+
+### .getX( index : number ) : number
+
+Returns the x component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**Returns:** The x component.
+
+### .getY( index : number ) : number
+
+Returns the y component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**Returns:** The y component.
+
+### .getZ( index : number ) : number
+
+Returns the z component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**Returns:** The z component.
+
+### .onUpload( callback : function ) : BufferAttribute
+
+Sets the given callback function that is executed after the Renderer has transferred the attribute array data to the GPU. Can be used to perform clean-up operations after the upload when attribute data are not needed anymore on the CPU side.
+
+**callback**
+
+The `onUpload()` callback.
+
+**Returns:** A reference to this instance.
+
+### .onUploadCallback()
+
+A callback function that is executed after the renderer has transferred the attribute array data to the GPU.
+
+### .set( value : TypedArray | Array, offset : number ) : BufferAttribute
+
+Sets the given array data in the buffer attribute.
+
+**value**
+
+The array data to set.
+
+**offset**
+
+The offset in this buffer attribute's array.
+
+Default is `0`.
+
+**Returns:** A reference to this instance.
+
+### .setComponent( index : number, component : number, value : number ) : BufferAttribute
+
+Sets the given value to the given component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**component**
+
+The component index.
+
+**value**
+
+The value to set.
+
+**Returns:** A reference to this instance.
+
+### .setUsage( value : StaticDrawUsage | DynamicDrawUsage | StreamDrawUsage | StaticReadUsage | DynamicReadUsage | StreamReadUsage | StaticCopyUsage | DynamicCopyUsage | StreamCopyUsage ) : BufferAttribute
+
+Sets the usage of this buffer attribute.
+
+**value**
+
+The usage to set.
+
+**Returns:** A reference to this buffer attribute.
+
+### .setW( index : number, w : number ) : BufferAttribute
+
+Sets the w component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**w**
+
+The value to set.
+
+**Returns:** A reference to this instance.
+
+### .setX( index : number, x : number ) : BufferAttribute
+
+Sets the x component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**x**
+
+The value to set.
+
+**Returns:** A reference to this instance.
+
+### .setXY( index : number, x : number, y : number ) : BufferAttribute
+
+Sets the x and y component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**x**
+
+The value for the x component to set.
+
+**y**
+
+The value for the y component to set.
+
+**Returns:** A reference to this instance.
+
+### .setXYZ( index : number, x : number, y : number, z : number ) : BufferAttribute
+
+Sets the x, y and z component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**x**
+
+The value for the x component to set.
+
+**y**
+
+The value for the y component to set.
+
+**z**
+
+The value for the z component to set.
+
+**Returns:** A reference to this instance.
+
+### .setXYZW( index : number, x : number, y : number, z : number, w : number ) : BufferAttribute
+
+Sets the x, y, z and w component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**x**
+
+The value for the x component to set.
+
+**y**
+
+The value for the y component to set.
+
+**z**
+
+The value for the z component to set.
+
+**w**
+
+The value for the w component to set.
+
+**Returns:** A reference to this instance.
+
+### .setY( index : number, y : number ) : BufferAttribute
+
+Sets the y component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**y**
+
+The value to set.
+
+**Returns:** A reference to this instance.
+
+### .setZ( index : number, z : number ) : BufferAttribute
+
+Sets the z component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**z**
+
+The value to set.
+
+**Returns:** A reference to this instance.
+
+### .toJSON() : Object
+
+Serializes the buffer attribute into JSON.
+
+**Returns:** A JSON object representing the serialized buffer attribute.
+
+### .transformDirection( m : Matrix4 ) : BufferAttribute
+
+Applies the given 4x4 matrix to the given attribute. Only works with item size `3` and with direction vectors.
+
+**m**
+
+The matrix to apply.
+
+**Returns:** A reference to this instance.
+
+## Source
+
+[src/core/BufferAttribute.js](https://github.com/mrdoob/three.js/blob/master/src/core/BufferAttribute.js)
\ No newline at end of file
diff --git a/docs/pages/BufferAttributeNode.html.md b/docs/pages/BufferAttributeNode.html.md
new file mode 100644
index 00000000000000..186ea131e7d068
--- /dev/null
+++ b/docs/pages/BufferAttributeNode.html.md
@@ -0,0 +1,187 @@
+*Inheritance: EventDispatcher → Node → InputNode →*
+
+# BufferAttributeNode
+
+In earlier `three.js` versions it was only possible to define attribute data on geometry level. With `BufferAttributeNode`, it is also possible to do this on the node level.
+
+This new approach is especially interesting when geometry data are generated via compute shaders. The below line converts a storage buffer into an attribute node.
+
+```js
+material.positionNode = positionBuffer.toAttribute();
+```
+
+## Code Example
+
+```js
+const geometry = new THREE.PlaneGeometry();
+const positionAttribute = geometry.getAttribute( 'position' );
+const colors = [];
+for ( let i = 0; i < position.count; i ++ ) {
+ colors.push( 1, 0, 0 );
+}
+material.colorNode = bufferAttribute( new THREE.Float32BufferAttribute( colors, 3 ) );
+```
+
+## Constructor
+
+### new BufferAttributeNode( value : BufferAttribute | InterleavedBuffer | TypedArray, bufferType : string, bufferStride : number, bufferOffset : number )
+
+Constructs a new buffer attribute node.
+
+**value**
+
+The attribute data.
+
+**bufferType**
+
+The buffer type (e.g. `'vec3'`).
+
+Default is `null`.
+
+**bufferStride**
+
+The buffer stride.
+
+Default is `0`.
+
+**bufferOffset**
+
+The buffer offset.
+
+Default is `0`.
+
+## Properties
+
+### .attribute : BufferAttribute
+
+A reference to the buffer attribute.
+
+Default is `null`.
+
+### .bufferOffset : number
+
+The buffer offset.
+
+Default is `0`.
+
+### .bufferStride : number
+
+The buffer stride.
+
+Default is `0`.
+
+### .bufferType : string
+
+The buffer type (e.g. `'vec3'`).
+
+Default is `null`.
+
+### .global : boolean
+
+`BufferAttributeNode` sets this property to `true` by default.
+
+Default is `true`.
+
+**Overrides:** [InputNode#global](InputNode.html#global)
+
+### .instanced : boolean
+
+Whether the attribute is instanced or not.
+
+Default is `false`.
+
+### .isBufferNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .usage : number
+
+The usage property. Set this to `THREE.DynamicDrawUsage` via `.setUsage()`, if you are planning to update the attribute data per frame.
+
+Default is `StaticDrawUsage`.
+
+## Methods
+
+### .generate( builder : NodeBuilder ) : string
+
+Generates the code snippet of the buffer attribute node.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [InputNode#generate](InputNode.html#generate)
+
+**Returns:** The generated code snippet.
+
+### .getHash( builder : NodeBuilder ) : string
+
+This method is overwritten since the attribute data might be shared and thus the hash should be shared as well.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [InputNode#getHash](InputNode.html#getHash)
+
+**Returns:** The hash.
+
+### .getInputType( builder : NodeBuilder ) : string
+
+Overwrites the default implementation to return a fixed value `'bufferAttribute'`.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [InputNode#getInputType](InputNode.html#getInputType)
+
+**Returns:** The input type.
+
+### .getNodeType( builder : NodeBuilder ) : string
+
+This method is overwritten since the node type is inferred from the buffer attribute.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [InputNode#getNodeType](InputNode.html#getNodeType)
+
+**Returns:** The node type.
+
+### .setInstanced( value : boolean ) : BufferAttributeNode
+
+Sets the `instanced` property to the given value.
+
+**value**
+
+The value to set.
+
+**Returns:** A reference to this node.
+
+### .setUsage( value : number ) : BufferAttributeNode
+
+Sets the `usage` property to the given value.
+
+**value**
+
+The usage to set.
+
+**Returns:** A reference to this node.
+
+### .setup( builder : NodeBuilder )
+
+Depending on which value was passed to the node, `setup()` behaves differently. If no instance of `BufferAttribute` was passed, the method creates an internal attribute and configures it respectively.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [InputNode#setup](InputNode.html#setup)
+
+## Source
+
+[src/nodes/accessors/BufferAttributeNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/accessors/BufferAttributeNode.js)
\ No newline at end of file
diff --git a/docs/pages/BufferGeometry.html.md b/docs/pages/BufferGeometry.html.md
new file mode 100644
index 00000000000000..b160aa2c52f7bc
--- /dev/null
+++ b/docs/pages/BufferGeometry.html.md
@@ -0,0 +1,411 @@
+*Inheritance: EventDispatcher →*
+
+# BufferGeometry
+
+A representation of mesh, line, or point geometry. Includes vertex positions, face indices, normals, colors, UVs, and custom attributes within buffers, reducing the cost of passing all this data to the GPU.
+
+## Code Example
+
+```js
+const geometry = new THREE.BufferGeometry();
+// create a simple square shape. We duplicate the top left and bottom right
+// vertices because each vertex needs to appear once per triangle.
+const vertices = new Float32Array( [
+ -1.0, -1.0, 1.0, // v0
+ 1.0, -1.0, 1.0, // v1
+ 1.0, 1.0, 1.0, // v2
+ 1.0, 1.0, 1.0, // v3
+ -1.0, 1.0, 1.0, // v4
+ -1.0, -1.0, 1.0 // v5
+] );
+// itemSize = 3 because there are 3 values (components) per vertex
+geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
+const material = new THREE.MeshBasicMaterial( { color: 0xff0000 } );
+const mesh = new THREE.Mesh( geometry, material );
+```
+
+## Constructor
+
+### new BufferGeometry()
+
+Constructs a new geometry.
+
+## Properties
+
+### .attributes : Object.
+
+This dictionary has as id the name of the attribute to be set and as value the buffer attribute to set it to. Rather than accessing this property directly, use `setAttribute()` and `getAttribute()` to access attributes of this geometry.
+
+### .boundingBox : Box3
+
+Bounding box for the geometry which can be calculated with `computeBoundingBox()`.
+
+Default is `null`.
+
+### .boundingSphere : Sphere
+
+Bounding sphere for the geometry which can be calculated with `computeBoundingSphere()`.
+
+Default is `null`.
+
+### .drawRange : Object
+
+Determines the part of the geometry to render. This should not be set directly, instead use `setDrawRange()`.
+
+### .groups : Array.
+
+Split the geometry into groups, each of which will be rendered in a separate draw call. This allows an array of materials to be used with the geometry.
+
+Use `addGroup()` and `clearGroups()` to edit groups, rather than modifying this array directly.
+
+Every vertex and index must belong to exactly one group — groups must not share vertices or indices, and must not leave vertices or indices unused.
+
+### .id : number (readonly)
+
+The ID of the geometry.
+
+### .index : BufferAttribute
+
+Allows for vertices to be re-used across multiple triangles; this is called using "indexed triangles". Each triangle is associated with the indices of three vertices. This attribute therefore stores the index of each vertex for each triangular face. If this attribute is not set, the renderer assumes that each three contiguous positions represent a single triangle.
+
+Default is `null`.
+
+### .indirect : BufferAttribute
+
+A (storage) buffer attribute which was generated with a compute shader and now defines indirect draw calls.
+
+Can only be used with [WebGPURenderer](WebGPURenderer.html) and a WebGPU backend.
+
+Default is `null`.
+
+### .indirectOffset : number | Array.
+
+The offset, in bytes, into the indirect drawing buffer where the value data begins. If an array is provided, multiple indirect draw calls will be made for each offset.
+
+Can only be used with [WebGPURenderer](WebGPURenderer.html) and a WebGPU backend.
+
+Default is `0`.
+
+### .isBufferGeometry : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .morphAttributes : Object
+
+This dictionary holds the morph targets of the geometry.
+
+Note: Once the geometry has been rendered, the morph attribute data cannot be changed. You will have to call `dispose()`, and create a new geometry instance.
+
+### .morphTargetsRelative : boolean
+
+Used to control the morph target behavior; when set to `true`, the morph target data is treated as relative offsets, rather than as absolute positions/normals.
+
+Default is `false`.
+
+### .name : string
+
+The name of the geometry.
+
+### .userData : Object
+
+An object that can be used to store custom data about the geometry. It should not hold references to functions as these will not be cloned.
+
+### .uuid : string (readonly)
+
+The UUID of the geometry.
+
+## Methods
+
+### .addGroup( start : number, count : number, materialIndex : number )
+
+Adds a group to this geometry.
+
+**start**
+
+The first element in this draw call. That is the first vertex for non-indexed geometry, otherwise the first triangle index.
+
+**count**
+
+Specifies how many vertices (or indices) are part of this group.
+
+**materialIndex**
+
+The material array index to use.
+
+Default is `0`.
+
+### .applyMatrix4( matrix : Matrix4 ) : BufferGeometry
+
+Applies the given 4x4 transformation matrix to the geometry.
+
+**matrix**
+
+The matrix to apply.
+
+**Returns:** A reference to this instance.
+
+### .applyQuaternion( q : Quaternion ) : BufferGeometry
+
+Applies the rotation represented by the Quaternion to the geometry.
+
+**q**
+
+The Quaternion to apply.
+
+**Returns:** A reference to this instance.
+
+### .center() : BufferGeometry
+
+Center the geometry based on its bounding box.
+
+**Returns:** A reference to this instance.
+
+### .clearGroups()
+
+Clears all groups.
+
+### .clone() : BufferGeometry
+
+Returns a new geometry with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .computeBoundingBox()
+
+Computes the bounding box of the geometry, and updates the `boundingBox` member. The bounding box is not computed by the engine; it must be computed by your app. You may need to recompute the bounding box if the geometry vertices are modified.
+
+### .computeBoundingSphere()
+
+Computes the bounding sphere of the geometry, and updates the `boundingSphere` member. The engine automatically computes the bounding sphere when it is needed, e.g., for ray casting or view frustum culling. You may need to recompute the bounding sphere if the geometry vertices are modified.
+
+### .computeTangents()
+
+Calculates and adds a tangent attribute to this geometry.
+
+The computation is only supported for indexed geometries and if position, normal, and uv attributes are defined. When using a tangent space normal map, prefer the MikkTSpace algorithm provided by BufferGeometryUtils#computeMikkTSpaceTangents instead.
+
+### .computeVertexNormals()
+
+Computes vertex normals for the given vertex data. For indexed geometries, the method sets each vertex normal to be the average of the face normals of the faces that share that vertex. For non-indexed geometries, vertices are not shared, and the method sets each vertex normal to be the same as the face normal.
+
+### .copy( source : BufferGeometry ) : BufferGeometry
+
+Copies the values of the given geometry to this instance.
+
+**source**
+
+The geometry to copy.
+
+**Returns:** A reference to this instance.
+
+### .deleteAttribute( name : string ) : BufferGeometry
+
+Deletes the attribute for the given name.
+
+**name**
+
+The attribute name to delete.
+
+**Returns:** A reference to this instance.
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+##### Fires:
+
+* BufferGeometry#event:dispose
+
+### .getAttribute( name : string ) : BufferAttribute | InterleavedBufferAttribute | undefined
+
+Returns the buffer attribute for the given name.
+
+**name**
+
+The attribute name.
+
+**Returns:** The buffer attribute. Returns `undefined` if not attribute has been found.
+
+### .getIndex() : BufferAttribute
+
+Returns the index of this geometry.
+
+**Returns:** The index. Returns `null` if no index is defined.
+
+### .getIndirect() : BufferAttribute
+
+Returns the indirect attribute of this geometry.
+
+**Returns:** The indirect attribute. Returns `null` if no indirect attribute is defined.
+
+### .hasAttribute( name : string ) : boolean
+
+Returns `true` if this geometry has an attribute for the given name.
+
+**name**
+
+The attribute name.
+
+**Returns:** Whether this geometry has an attribute for the given name or not.
+
+### .lookAt( vector : Vector3 ) : BufferGeometry
+
+Rotates the geometry to face a point in 3D space. This is typically done as a one time operation, and not during a loop. Use [Object3D#lookAt](Object3D.html#lookAt) for typical real-time mesh rotation.
+
+**vector**
+
+The target point.
+
+**Returns:** A reference to this instance.
+
+### .normalizeNormals()
+
+Ensures every normal vector in a geometry will have a magnitude of `1`. This will correct lighting on the geometry surfaces.
+
+### .rotateX( angle : number ) : BufferGeometry
+
+Rotates the geometry about the X axis. This is typically done as a one time operation, and not during a loop. Use [Object3D#rotation](Object3D.html#rotation) for typical real-time mesh rotation.
+
+**angle**
+
+The angle in radians.
+
+**Returns:** A reference to this instance.
+
+### .rotateY( angle : number ) : BufferGeometry
+
+Rotates the geometry about the Y axis. This is typically done as a one time operation, and not during a loop. Use [Object3D#rotation](Object3D.html#rotation) for typical real-time mesh rotation.
+
+**angle**
+
+The angle in radians.
+
+**Returns:** A reference to this instance.
+
+### .rotateZ( angle : number ) : BufferGeometry
+
+Rotates the geometry about the Z axis. This is typically done as a one time operation, and not during a loop. Use [Object3D#rotation](Object3D.html#rotation) for typical real-time mesh rotation.
+
+**angle**
+
+The angle in radians.
+
+**Returns:** A reference to this instance.
+
+### .scale( x : number, y : number, z : number ) : BufferGeometry
+
+Scales the geometry. This is typically done as a one time operation, and not during a loop. Use [Object3D#scale](Object3D.html#scale) for typical real-time mesh rotation.
+
+**x**
+
+The x scale.
+
+**y**
+
+The y scale.
+
+**z**
+
+The z scale.
+
+**Returns:** A reference to this instance.
+
+### .setAttribute( name : string, attribute : BufferAttribute | InterleavedBufferAttribute ) : BufferGeometry
+
+Sets the given attribute for the given name.
+
+**name**
+
+The attribute name.
+
+**attribute**
+
+The attribute to set.
+
+**Returns:** A reference to this instance.
+
+### .setDrawRange( start : number, count : number )
+
+Sets the draw range for this geometry.
+
+**start**
+
+The first vertex for non-indexed geometry, otherwise the first triangle index.
+
+**count**
+
+For non-indexed BufferGeometry, `count` is the number of vertices to render. For indexed BufferGeometry, `count` is the number of indices to render.
+
+### .setFromPoints( points : Array. | Array. ) : BufferGeometry
+
+Defines a geometry by creating a `position` attribute based on the given array of points. The array can hold 2D or 3D vectors. When using two-dimensional data, the `z` coordinate for all vertices is set to `0`.
+
+If the method is used with an existing `position` attribute, the vertex data are overwritten with the data from the array. The length of the array must match the vertex count.
+
+**points**
+
+The points.
+
+**Returns:** A reference to this instance.
+
+### .setIndex( index : Array. | BufferAttribute ) : BufferGeometry
+
+Sets the given index to this geometry.
+
+**index**
+
+The index to set.
+
+**Returns:** A reference to this instance.
+
+### .setIndirect( indirect : BufferAttribute, indirectOffset : number | Array. ) : BufferGeometry
+
+Sets the given indirect attribute to this geometry.
+
+**indirect**
+
+The attribute holding indirect draw calls.
+
+**indirectOffset**
+
+The offset, in bytes, into the indirect drawing buffer where the value data begins. If an array is provided, multiple indirect draw calls will be made for each offset.
+
+Default is `0`.
+
+**Returns:** A reference to this instance.
+
+### .toJSON() : Object
+
+Serializes the geometry into JSON.
+
+**Returns:** A JSON object representing the serialized geometry.
+
+### .toNonIndexed() : BufferGeometry
+
+Return a new non-index version of this indexed geometry. If the geometry is already non-indexed, the method is a NOOP.
+
+**Returns:** The non-indexed version of this indexed geometry.
+
+### .translate( x : number, y : number, z : number ) : BufferGeometry
+
+Translates the geometry. This is typically done as a one time operation, and not during a loop. Use [Object3D#position](Object3D.html#position) for typical real-time mesh rotation.
+
+**x**
+
+The x offset.
+
+**y**
+
+The y offset.
+
+**z**
+
+The z offset.
+
+**Returns:** A reference to this instance.
+
+## Source
+
+[src/core/BufferGeometry.js](https://github.com/mrdoob/three.js/blob/master/src/core/BufferGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/BufferGeometryLoader.html.md b/docs/pages/BufferGeometryLoader.html.md
new file mode 100644
index 00000000000000..3bd8bc3c990529
--- /dev/null
+++ b/docs/pages/BufferGeometryLoader.html.md
@@ -0,0 +1,65 @@
+*Inheritance: Loader →*
+
+# BufferGeometryLoader
+
+Class for loading geometries. The files are internally loaded via [FileLoader](FileLoader.html).
+
+## Code Example
+
+```js
+const loader = new THREE.BufferGeometryLoader();
+const geometry = await loader.loadAsync( 'models/json/pressure.json' );
+const material = new THREE.MeshBasicMaterial( { color: 0xF5F5F5 } );
+const object = new THREE.Mesh( geometry, material );
+scene.add( object );
+```
+
+## Constructor
+
+### new BufferGeometryLoader( manager : LoadingManager )
+
+Constructs a new geometry loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and pass the loaded geometry to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( json : Object ) : BufferGeometry
+
+Parses the given JSON object and returns a geometry.
+
+**json**
+
+The serialized geometry.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** The parsed geometry.
+
+## Source
+
+[src/loaders/BufferGeometryLoader.js](https://github.com/mrdoob/three.js/blob/master/src/loaders/BufferGeometryLoader.js)
\ No newline at end of file
diff --git a/docs/pages/BufferNode.html.md b/docs/pages/BufferNode.html.md
new file mode 100644
index 00000000000000..f5cf929b46d3ed
--- /dev/null
+++ b/docs/pages/BufferNode.html.md
@@ -0,0 +1,102 @@
+*Inheritance: EventDispatcher → Node → InputNode → UniformNode →*
+
+# BufferNode
+
+A special type of uniform node which represents array-like data as uniform buffers. The access usually happens via `element()` which returns an instance of [ArrayElementNode](ArrayElementNode.html). For example:
+
+In general, it is recommended to use the more managed [UniformArrayNode](UniformArrayNode.html) since it handles more input types and automatically cares about buffer paddings.
+
+## Code Example
+
+```js
+const bufferNode = buffer( array, 'mat4', count );
+const matrixNode = bufferNode.element( index ); // access a matrix from the buffer
+```
+
+## Constructor
+
+### new BufferNode( value : Array., bufferType : string, bufferCount : number )
+
+Constructs a new buffer node.
+
+**value**
+
+Array-like buffer data.
+
+**bufferType**
+
+The data type of the buffer.
+
+**bufferCount**
+
+The count of buffer elements.
+
+Default is `0`.
+
+## Properties
+
+### .bufferCount : number
+
+The uniform node that holds the value of the reference node.
+
+Default is `0`.
+
+### .bufferType : string
+
+The data type of the buffer.
+
+### .isBufferNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .updateRanges : Array.<{start: number, count: number}>
+
+An array of update ranges.
+
+## Methods
+
+### .addUpdateRange( start : number, count : number )
+
+Adds a range of data in the data array to be updated on the GPU.
+
+**start**
+
+Position at which to start update.
+
+**count**
+
+The number of components to update.
+
+### .clearUpdateRanges()
+
+Clears the update ranges.
+
+### .getElementType( builder : NodeBuilder ) : string
+
+The data type of the buffer elements.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [UniformNode#getElementType](UniformNode.html#getElementType)
+
+**Returns:** The element type.
+
+### .getInputType( builder : NodeBuilder ) : string
+
+Overwrites the default implementation to return a fixed value `'buffer'`.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [UniformNode#getInputType](UniformNode.html#getInputType)
+
+**Returns:** The input type.
+
+## Source
+
+[src/nodes/accessors/BufferNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/accessors/BufferNode.js)
\ No newline at end of file
diff --git a/docs/pages/BuiltinNode.html.md b/docs/pages/BuiltinNode.html.md
new file mode 100644
index 00000000000000..3174271b0c305f
--- /dev/null
+++ b/docs/pages/BuiltinNode.html.md
@@ -0,0 +1,47 @@
+*Inheritance: EventDispatcher → Node →*
+
+# BuiltinNode
+
+The node allows to set values for built-in shader variables. That is required for features like hardware-accelerated vertex clipping.
+
+## Constructor
+
+### new BuiltinNode( name : string )
+
+Constructs a new builtin node.
+
+**name**
+
+The name of the built-in shader variable.
+
+## Properties
+
+### .isBuiltinNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .name : string
+
+The name of the built-in shader variable.
+
+**Overrides:** [Node#name](Node.html#name)
+
+## Methods
+
+### .generate( builder : NodeBuilder ) : string
+
+Generates the code snippet of the builtin node.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [Node#generate](Node.html#generate)
+
+**Returns:** The generated code snippet.
+
+## Source
+
+[src/nodes/accessors/BuiltinNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/accessors/BuiltinNode.js)
\ No newline at end of file
diff --git a/docs/pages/BumpMapNode.html.md b/docs/pages/BumpMapNode.html.md
new file mode 100644
index 00000000000000..d7995656202b2a
--- /dev/null
+++ b/docs/pages/BumpMapNode.html.md
@@ -0,0 +1,43 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# BumpMapNode
+
+This class can be used for applying bump maps to materials.
+
+## Code Example
+
+```js
+material.normalNode = bumpMap( texture( bumpTex ) );
+```
+
+## Constructor
+
+### new BumpMapNode( textureNode : Node., scaleNode : Node. )
+
+Constructs a new bump map node.
+
+**textureNode**
+
+Represents the bump map data.
+
+**scaleNode**
+
+Controls the intensity of the bump effect.
+
+Default is `null`.
+
+## Properties
+
+### .scaleNode : Node.
+
+Controls the intensity of the bump effect.
+
+Default is `null`.
+
+### .textureNode : Node.
+
+Represents the bump map data.
+
+## Source
+
+[src/nodes/display/BumpMapNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/display/BumpMapNode.js)
\ No newline at end of file
diff --git a/docs/pages/BundleGroup.html.md b/docs/pages/BundleGroup.html.md
new file mode 100644
index 00000000000000..2849a49c7c5c13
--- /dev/null
+++ b/docs/pages/BundleGroup.html.md
@@ -0,0 +1,53 @@
+*Inheritance: EventDispatcher → Object3D → Group →*
+
+# BundleGroup
+
+A specialized group which enables applications access to the Render Bundle API of WebGPU. The group with all its descendant nodes are considered as one render bundle and processed as such by the renderer.
+
+This module is only fully supported by `WebGPURenderer` with a WebGPU backend. With a WebGL backend, the group can technically be rendered but without any performance improvements.
+
+## Constructor
+
+### new BundleGroup()
+
+Constructs a new bundle group.
+
+## Properties
+
+### .isBundleGroup : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .needsUpdate : boolean
+
+Set this property to `true` when the bundle group has changed.
+
+Default is `false`.
+
+### .static : boolean
+
+Whether the bundle is static or not. When set to `true`, the structure is assumed to be static and does not change. E.g. no new objects are added to the group
+
+If a change is required, an update can still be forced by setting the `needsUpdate` flag to `true`.
+
+Default is `true`.
+
+### .type : string (readonly)
+
+This property is only relevant for detecting types during serialization/deserialization. It should always match the class name.
+
+Default is `'BundleGroup'`.
+
+**Overrides:** [Group#type](Group.html#type)
+
+### .version : number (readonly)
+
+The bundle group's version.
+
+Default is `0`.
+
+## Source
+
+[src/renderers/common/BundleGroup.js](https://github.com/mrdoob/three.js/blob/master/src/renderers/common/BundleGroup.js)
\ No newline at end of file
diff --git a/docs/pages/BypassNode.html.md b/docs/pages/BypassNode.html.md
new file mode 100644
index 00000000000000..eb6b72921aafcf
--- /dev/null
+++ b/docs/pages/BypassNode.html.md
@@ -0,0 +1,45 @@
+*Inheritance: EventDispatcher → Node →*
+
+# BypassNode
+
+The class generates the code of a given node but returns another node in the output. This can be used to call a method or node that does not return a value, i.e. type `void` on an input where returning a value is required. Example:
+
+## Code Example
+
+```js
+material.colorNode = myColor.bypass( runVoidFn() )
+```
+
+## Constructor
+
+### new BypassNode( outputNode : Node, callNode : Node )
+
+Constructs a new bypass node.
+
+**outputNode**
+
+The output node.
+
+**callNode**
+
+The call node.
+
+## Properties
+
+### .callNode : Node
+
+The call node.
+
+### .isBypassNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .outputNode : Node
+
+The output node.
+
+## Source
+
+[src/nodes/core/BypassNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/core/BypassNode.js)
\ No newline at end of file
diff --git a/docs/pages/CCDIKHelper.html.md b/docs/pages/CCDIKHelper.html.md
new file mode 100644
index 00000000000000..f303ac97e99d48
--- /dev/null
+++ b/docs/pages/CCDIKHelper.html.md
@@ -0,0 +1,73 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# CCDIKHelper
+
+Helper for visualizing IK bones.
+
+## Import
+
+CCDIKHelper is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { CCDIKHelper } from 'three/addons/animation/CCDIKSolver.js';
+```
+
+## Constructor
+
+### new CCDIKHelper( mesh : SkinnedMesh, iks : Array., sphereSize : number )
+
+**mesh**
+
+The skinned mesh.
+
+**iks**
+
+The IK objects.
+
+Default is `[]`.
+
+**sphereSize**
+
+The sphere size.
+
+Default is `0.25`.
+
+## Properties
+
+### .effectorSphereMaterial : MeshBasicMaterial
+
+The material for the effector spheres.
+
+### .iks : Array.
+
+The IK objects.
+
+### .lineMaterial : LineBasicMaterial
+
+A global line material.
+
+### .linkSphereMaterial : MeshBasicMaterial
+
+The material for the link spheres.
+
+### .root : SkinnedMesh
+
+The skinned mesh this helper refers to.
+
+### .sphereGeometry : SkinnedMesh
+
+The helpers sphere geometry.
+
+### .targetSphereMaterial : MeshBasicMaterial
+
+The material for the target spheres.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+## Source
+
+[examples/jsm/animation/CCDIKSolver.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/animation/CCDIKSolver.js)
\ No newline at end of file
diff --git a/docs/pages/CCDIKSolver.html.md b/docs/pages/CCDIKSolver.html.md
new file mode 100644
index 00000000000000..3ad1b4672a7e5e
--- /dev/null
+++ b/docs/pages/CCDIKSolver.html.md
@@ -0,0 +1,155 @@
+# CCDIKSolver
+
+This class solves the Inverse Kinematics Problem with a [CCD Algorithm](https://web.archive.org/web/20221206080850/https://sites.google.com/site/auraliusproject/ccd-algorithm).
+
+`CCDIKSolver` is designed to work with instances of [SkinnedMesh](SkinnedMesh.html).
+
+## Import
+
+CCDIKSolver is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { CCDIKSolver } from 'three/addons/animation/CCDIKSolver.js';
+```
+
+## Constructor
+
+### new CCDIKSolver( mesh : SkinnedMesh, iks : Array. )
+
+**mesh**
+
+The skinned mesh.
+
+**iks**
+
+The IK objects.
+
+Default is `[]`.
+
+## Properties
+
+### .iks : SkinnedMesh
+
+The IK objects.
+
+### .mesh : SkinnedMesh
+
+The skinned mesh.
+
+## Methods
+
+### .createHelper( sphereSize : number ) : CCDIKHelper
+
+Creates a helper for visualizing the CCDIK.
+
+**sphereSize**
+
+The sphere size.
+
+**Returns:** The created helper.
+
+### .update( globalBlendFactor : number ) : CCDIKSolver
+
+Updates all IK bones by solving the CCD algorithm.
+
+**globalBlendFactor**
+
+Blend factor applied if an IK chain doesn't have its own .blendFactor.
+
+Default is `1.0`.
+
+**Returns:** A reference to this instance.
+
+### .updateOne( ik : CCDIKSolver~IK, overrideBlend : number ) : CCDIKSolver
+
+Updates one IK bone solving the CCD algorithm.
+
+**ik**
+
+The IK to update.
+
+**overrideBlend**
+
+If the IK object does not define `blendFactor`, this value is used.
+
+Default is `1.0`.
+
+**Returns:** A reference to this instance.
+
+## Type Definitions
+
+### .BoneLink
+
+This type represents bone links.
+
+**index**
+number
+
+The index of a linked bone which refers to a bone in the `Skeleton.bones` array.
+
+**limitation**
+number
+
+Rotation axis.
+
+**rotationMin**
+number
+
+Rotation minimum limit.
+
+**rotationMax**
+number
+
+Rotation maximum limit.
+
+**enabled**
+boolean
+
+Whether the link is enabled or not.
+
+Default is `true`.
+
+### .IK
+
+This type represents IK configuration objects.
+
+**target**
+number
+
+The target bone index which refers to a bone in the `Skeleton.bones` array.
+
+**effector**
+number
+
+The effector bone index which refers to a bone in the `Skeleton.bones` array.
+
+**links**
+Array.<[CCDIKSolver~BoneLink](CCDIKSolver.html#~BoneLink)\>
+
+An array of bone links.
+
+**iteration**
+number
+
+Iteration number of calculation. Smaller is faster but less precise.
+
+Default is `1`.
+
+**minAngle**
+number
+
+Minimum rotation angle in a step in radians.
+
+**maxAngle**
+number
+
+Minimum rotation angle in a step in radians.
+
+**blendFactor**
+number
+
+The blend factor.
+
+## Source
+
+[examples/jsm/animation/CCDIKSolver.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/animation/CCDIKSolver.js)
\ No newline at end of file
diff --git a/docs/pages/CSM.html.md b/docs/pages/CSM.html.md
new file mode 100644
index 00000000000000..418b999176d97d
--- /dev/null
+++ b/docs/pages/CSM.html.md
@@ -0,0 +1,244 @@
+# CSM
+
+An implementation of Cascade Shadow Maps (CSM).
+
+This module can only be used with [WebGLRenderer](WebGLRenderer.html). When using [WebGPURenderer](WebGPURenderer.html), use [CSMShadowNode](CSMShadowNode.html) instead.
+
+## Import
+
+CSM is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { CSM } from 'three/addons/csm/CSM.js';
+```
+
+## Constructor
+
+### new CSM( data : CSM~Data )
+
+Constructs a new CSM instance.
+
+**data**
+
+The CSM data.
+
+## Classes
+
+[CSM](CSM.html)
+
+## Properties
+
+### .breaks : Array.
+
+An array of numbers in the range `[0,1]` the defines how the mainCSM frustum should be split up.
+
+### .camera : Camera
+
+The scene's camera.
+
+### .cascades : number
+
+The number of cascades.
+
+Default is `3`.
+
+### .customSplitsCallback : function
+
+Custom split callback when using `mode='custom'`.
+
+### .fade : boolean
+
+Whether to fade between cascades or not.
+
+Default is `false`.
+
+### .frustums : Array.
+
+An array of frustums representing the cascades.
+
+### .lightDirection : Vector3
+
+The light direction.
+
+### .lightFar : number
+
+The light far value.
+
+Default is `2000`.
+
+### .lightIntensity : number
+
+The light intensity.
+
+Default is `3`.
+
+### .lightMargin : number
+
+The light margin.
+
+Default is `200`.
+
+### .lightNear : number
+
+The light near value.
+
+Default is `1`.
+
+### .lights : Array.
+
+An array of directional lights which cast the shadows for the different cascades. There is one directional light for each cascade.
+
+### .mainFrustum : CSMFrustum
+
+The main frustum.
+
+### .maxFar : number
+
+The maximum far value.
+
+Default is `100000`.
+
+### .mode : 'practical' | 'uniform' | 'logarithmic' | 'custom'
+
+The frustum split mode.
+
+Default is `'practical'`.
+
+### .parent : Object3D
+
+The parent object, usually the scene.
+
+### .shaders : Map.
+
+A Map holding enhanced material shaders.
+
+### .shadowBias : number
+
+The shadow bias.
+
+Default is `0.000001`.
+
+### .shadowMapSize : number
+
+The shadow map size.
+
+Default is `2048`.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+### .remove()
+
+Applications must call this method when they remove the CSM usage from their scene.
+
+### .setupMaterial( material : Material )
+
+Applications must call this method for all materials that should be affected by CSM.
+
+**material**
+
+The material to setup for CSM support.
+
+### .update()
+
+Updates the CSM. This method must be called in your animation loop before calling `renderer.render()`.
+
+### .updateFrustums()
+
+Applications must call this method every time they change camera or CSM settings.
+
+## Type Definitions
+
+### .Data
+
+Constructor data of `CSM`.
+
+**camera**
+[Camera](Camera.html)
+
+The scene's camera.
+
+**parent**
+[Object3D](Object3D.html)
+
+The parent object, usually the scene.
+
+**cascades**
+number
+
+The number of cascades.
+
+Default is `3`.
+
+**maxFar**
+number
+
+The maximum far value.
+
+Default is `100000`.
+
+**mode**
+'practical' | 'uniform' | 'logarithmic' | 'custom'
+
+The frustum split mode.
+
+Default is `'practical'`.
+
+**customSplitsCallback**
+function
+
+Custom split callback when using `mode='custom'`.
+
+**shadowMapSize**
+number
+
+The shadow map size.
+
+Default is `2048`.
+
+**shadowBias**
+number
+
+The shadow bias.
+
+Default is `0.000001`.
+
+**lightDirection**
+[Vector3](Vector3.html)
+
+The light direction.
+
+**lightIntensity**
+number
+
+The light intensity.
+
+Default is `3`.
+
+**lightNear**
+number
+
+The light near value.
+
+Default is `1`.
+
+**lightNear**
+number
+
+The light far value.
+
+Default is `2000`.
+
+**lightMargin**
+number
+
+The light margin.
+
+Default is `200`.
+
+## Source
+
+[examples/jsm/csm/CSM.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/csm/CSM.js)
\ No newline at end of file
diff --git a/docs/pages/CSMFrustum.html.md b/docs/pages/CSMFrustum.html.md
new file mode 100644
index 00000000000000..70a1102af29af0
--- /dev/null
+++ b/docs/pages/CSMFrustum.html.md
@@ -0,0 +1,96 @@
+# CSMFrustum
+
+Represents the frustum of a CSM instance.
+
+## Import
+
+CSMFrustum is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { CSMFrustum } from 'three/addons/csm/CSMFrustum.js';
+```
+
+## Constructor
+
+### new CSMFrustum( data : CSMFrustum~Data )
+
+Constructs a new CSM frustum.
+
+**data**
+
+The CSM data.
+
+## Properties
+
+### .vertices : Object
+
+An object representing the vertices of the near and far plane in view space.
+
+### .zNear : number
+
+The zNear value. This value depends on whether the CSM is used with WebGL or WebGPU. Both API use different conventions for their projection matrices.
+
+## Methods
+
+### .setFromProjectionMatrix( projectionMatrix : Matrix4, maxFar : number ) : Object
+
+Setups this CSM frustum from the given projection matrix and max far value.
+
+**projectionMatrix**
+
+The projection matrix, usually of the scene's camera.
+
+**maxFar**
+
+The maximum far value.
+
+**Returns:** An object representing the vertices of the near and far plane in view space.
+
+### .split( breaks : Array., target : Array. )
+
+Splits the CSM frustum by the given array. The new CSM frustum are pushed into the given target array.
+
+**breaks**
+
+An array of numbers in the range `[0,1]` the defines how the CSM frustum should be split up.
+
+**target**
+
+The target array that holds the new CSM frustums.
+
+### .toSpace( cameraMatrix : Matrix4, target : CSMFrustum )
+
+Transforms the given target CSM frustum into the different coordinate system defined by the given camera matrix.
+
+**cameraMatrix**
+
+The matrix that defines the new coordinate system.
+
+**target**
+
+The CSM to convert.
+
+## Type Definitions
+
+### .Data
+
+Constructor data of `CSMFrustum`.
+
+**webGL**
+boolean
+
+Whether this CSM frustum is used with WebGL or WebGPU.
+
+**projectionMatrix**
+[Matrix4](Matrix4.html)
+
+A projection matrix usually of the scene's camera.
+
+**maxFar**
+number
+
+The maximum far value.
+
+## Source
+
+[examples/jsm/csm/CSMFrustum.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/csm/CSMFrustum.js)
\ No newline at end of file
diff --git a/docs/pages/CSMHelper.html.md b/docs/pages/CSMHelper.html.md
new file mode 100644
index 00000000000000..c67e1f138b2112
--- /dev/null
+++ b/docs/pages/CSMHelper.html.md
@@ -0,0 +1,65 @@
+*Inheritance: EventDispatcher → Object3D → Group →*
+
+# CSMHelper
+
+A helper for visualizing the cascades of a CSM instance.
+
+## Import
+
+CSMHelper is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { CSMHelper } from 'three/addons/csm/CSMHelper.js';
+```
+
+## Constructor
+
+### new CSMHelper( csm : CSM | CSMShadowNode )
+
+Constructs a new CSM helper.
+
+**csm**
+
+The CSM instance to visualize.
+
+## Properties
+
+### .csm : CSM | CSMShadowNode
+
+The CSM instance to visualize.
+
+### .displayFrustum : boolean
+
+Whether to display the CSM frustum or not.
+
+Default is `true`.
+
+### .displayPlanes : boolean
+
+Whether to display the cascade planes or not.
+
+Default is `true`.
+
+### .displayShadowBounds : boolean
+
+Whether to display the shadow bounds or not.
+
+Default is `true`.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+### .update()
+
+Updates the helper. This method should be called in the app's animation loop.
+
+### .updateVisibility()
+
+This method must be called if one of the `display*` properties is changed at runtime.
+
+## Source
+
+[examples/jsm/csm/CSMHelper.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/csm/CSMHelper.js)
\ No newline at end of file
diff --git a/docs/pages/CSMShadowNode.html.md b/docs/pages/CSMShadowNode.html.md
new file mode 100644
index 00000000000000..ef1e11e1650d3c
--- /dev/null
+++ b/docs/pages/CSMShadowNode.html.md
@@ -0,0 +1,146 @@
+*Inheritance: EventDispatcher → Node → ShadowBaseNode →*
+
+# CSMShadowNode
+
+An implementation of Cascade Shadow Maps (CSM).
+
+This module can only be used with [WebGPURenderer](WebGPURenderer.html). When using [WebGLRenderer](WebGLRenderer.html), use [CSM](CSM.html) instead.
+
+## Import
+
+CSMShadowNode is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { CSMShadowNode } from 'three/addons/csm/CSMShadowNode.js';
+```
+
+## Constructor
+
+### new CSMShadowNode( light : DirectionalLight, data : CSMShadowNode~Data )
+
+Constructs a new CSM shadow node.
+
+**light**
+
+The CSM light.
+
+**data**
+
+The CSM data.
+
+Default is `{}`.
+
+## Properties
+
+### .breaks : Array.
+
+An array of numbers in the range `[0,1]` the defines how the mainCSM frustum should be split up.
+
+### .camera : Camera
+
+The scene's camera.
+
+Default is `null`.
+
+### .cascades : number
+
+The number of cascades.
+
+Default is `3`.
+
+### .customSplitsCallback : function
+
+Custom split callback when using `mode='custom'`.
+
+### .fade : boolean
+
+Whether to fade between cascades or not.
+
+Default is `false`.
+
+### .frustums : Array.
+
+An array of frustums representing the cascades.
+
+### .lightMargin : number
+
+The light margin.
+
+Default is `200`.
+
+### .lights : Array.
+
+An array of directional lights which cast the shadows for the different cascades. There is one directional light for each cascade.
+
+### .mainFrustum : CSMFrustum
+
+The main frustum.
+
+Default is `null`.
+
+### .maxFar : number
+
+The maximum far value.
+
+Default is `100000`.
+
+### .mode : 'practical' | 'uniform' | 'logarithmic' | 'custom'
+
+The frustum split mode.
+
+Default is `'practical'`.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+**Overrides:** [ShadowBaseNode#dispose](ShadowBaseNode.html#dispose)
+
+### .updateFrustums()
+
+Applications must call this method every time they change camera or CSM settings.
+
+## Type Definitions
+
+### .Data
+
+Constructor data of `CSMShadowNode`.
+
+**cascades**
+number
+
+The number of cascades.
+
+Default is `3`.
+
+**maxFar**
+number
+
+The maximum far value.
+
+Default is `100000`.
+
+**mode**
+'practical' | 'uniform' | 'logarithmic' | 'custom'
+
+The frustum split mode.
+
+Default is `'practical'`.
+
+**customSplitsCallback**
+function
+
+Custom split callback when using `mode='custom'`.
+
+**lightMargin**
+number
+
+The light margin.
+
+Default is `200`.
+
+## Source
+
+[examples/jsm/csm/CSMShadowNode.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/csm/CSMShadowNode.js)
\ No newline at end of file
diff --git a/docs/pages/CSS2DObject.html.md b/docs/pages/CSS2DObject.html.md
new file mode 100644
index 00000000000000..900ed6e7faec80
--- /dev/null
+++ b/docs/pages/CSS2DObject.html.md
@@ -0,0 +1,47 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# CSS2DObject
+
+The only type of 3D object that is supported by [CSS2DRenderer](CSS2DRenderer.html).
+
+## Import
+
+CSS2DObject is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { CSS2DObject } from 'three/addons/renderers/CSS2DRenderer.js';
+```
+
+## Constructor
+
+### new CSS2DObject( element : HTMLElement )
+
+Constructs a new CSS2D object.
+
+**element**
+
+The DOM element.
+
+## Properties
+
+### .center : Vector2
+
+The 3D objects center point. `( 0, 0 )` is the lower left, `( 1, 1 )` is the top right.
+
+Default is `(0.5,0.5)`.
+
+### .element : HTMLElement (readonly)
+
+The DOM element which defines the appearance of this 3D object.
+
+Default is `true`.
+
+### .isCSS2DObject : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[examples/jsm/renderers/CSS2DRenderer.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/renderers/CSS2DRenderer.js)
\ No newline at end of file
diff --git a/docs/pages/CSS2DRenderer.html.md b/docs/pages/CSS2DRenderer.html.md
new file mode 100644
index 00000000000000..0f5b032386992a
--- /dev/null
+++ b/docs/pages/CSS2DRenderer.html.md
@@ -0,0 +1,84 @@
+# CSS2DRenderer
+
+This renderer is a simplified version of [CSS3DRenderer](CSS3DRenderer.html). The only transformation that is supported is translation.
+
+The renderer is very useful if you want to combine HTML based labels with 3D objects. Here too, the respective DOM elements are wrapped into an instance of [CSS2DObject](CSS2DObject.html) and added to the scene graph. All other types of renderable 3D objects (like meshes or point clouds) are ignored.
+
+`CSS2DRenderer` only supports 100% browser and display zoom.
+
+## Import
+
+CSS2DRenderer is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { CSS2DRenderer } from 'three/addons/renderers/CSS2DRenderer.js';
+```
+
+## Constructor
+
+### new CSS2DRenderer( parameters : CSS2DRenderer~Parameters )
+
+Constructs a new CSS2D renderer.
+
+**parameters**
+
+The parameters.
+
+## Properties
+
+### .domElement : HTMLElement
+
+The DOM where the renderer appends its child-elements.
+
+### .sortObjects : boolean
+
+Controls whether the renderer assigns `z-index` values to CSS2DObject DOM elements. If set to `true`, z-index values are assigned first based on the `renderOrder` and secondly - the distance to the camera. If set to `false`, no z-index values are assigned.
+
+Default is `true`.
+
+## Methods
+
+### .getSize() : Object
+
+Returns an object containing the width and height of the renderer.
+
+**Returns:** The size of the renderer.
+
+### .render( scene : Object3D, camera : Camera )
+
+Renders the given scene using the given camera.
+
+**scene**
+
+A scene or any other type of 3D object.
+
+**camera**
+
+The camera.
+
+### .setSize( width : number, height : number )
+
+Resizes the renderer to the given width and height.
+
+**width**
+
+The width of the renderer.
+
+**height**
+
+The height of the renderer.
+
+## Type Definitions
+
+### .Parameters
+
+Constructor parameters of `CSS2DRenderer`.
+
+**element**
+HTMLElement
+
+A DOM element where the renderer appends its child-elements. If not passed in here, a new div element will be created.
+
+## Source
+
+[examples/jsm/renderers/CSS2DRenderer.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/renderers/CSS2DRenderer.js)
\ No newline at end of file
diff --git a/docs/pages/CSS3DObject.html.md b/docs/pages/CSS3DObject.html.md
new file mode 100644
index 00000000000000..956d40423eff60
--- /dev/null
+++ b/docs/pages/CSS3DObject.html.md
@@ -0,0 +1,41 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# CSS3DObject
+
+The base 3D object that is supported by [CSS3DRenderer](CSS3DRenderer.html).
+
+## Import
+
+CSS3DObject is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { CSS3DObject } from 'three/addons/renderers/CSS3DRenderer.js';
+```
+
+## Constructor
+
+### new CSS3DObject( element : HTMLElement )
+
+Constructs a new CSS3D object.
+
+**element**
+
+The DOM element.
+
+## Properties
+
+### .element : HTMLElement (readonly)
+
+The DOM element which defines the appearance of this 3D object.
+
+Default is `true`.
+
+### .isCSS3DObject : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[examples/jsm/renderers/CSS3DRenderer.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/renderers/CSS3DRenderer.js)
\ No newline at end of file
diff --git a/docs/pages/CSS3DRenderer.html.md b/docs/pages/CSS3DRenderer.html.md
new file mode 100644
index 00000000000000..37d0fb0aad1117
--- /dev/null
+++ b/docs/pages/CSS3DRenderer.html.md
@@ -0,0 +1,82 @@
+# CSS3DRenderer
+
+This renderer can be used to apply hierarchical 3D transformations to DOM elements via the CSS3 [transform](https://www.w3schools.com/cssref/css3_pr_transform.asp) property. `CSS3DRenderer` is particularly interesting if you want to apply 3D effects to a website without canvas based rendering. It can also be used in order to combine DOM elements with WebGLcontent.
+
+There are, however, some important limitations:
+
+* It's not possible to use the material system of _three.js_.
+* It's also not possible to use geometries.
+* The renderer only supports 100% browser and display zoom.
+
+So `CSS3DRenderer` is just focused on ordinary DOM elements. These elements are wrapped into special 3D objects ([CSS3DObject](CSS3DObject.html) or [CSS3DSprite](CSS3DSprite.html)) and then added to the scene graph.
+
+## Import
+
+CSS3DRenderer is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { CSS3DRenderer } from 'three/addons/renderers/CSS3DRenderer.js';
+```
+
+## Constructor
+
+### new CSS3DRenderer( parameters : CSS3DRenderer~Parameters )
+
+Constructs a new CSS3D renderer.
+
+**parameters**
+
+The parameters.
+
+## Properties
+
+### .domElement : HTMLElement
+
+The DOM where the renderer appends its child-elements.
+
+## Methods
+
+### .getSize() : Object
+
+Returns an object containing the width and height of the renderer.
+
+**Returns:** The size of the renderer.
+
+### .render( scene : Object3D, camera : Camera )
+
+Renders the given scene using the given camera.
+
+**scene**
+
+A scene or any other type of 3D object.
+
+**camera**
+
+The camera.
+
+### .setSize( width : number, height : number )
+
+Resizes the renderer to the given width and height.
+
+**width**
+
+The width of the renderer.
+
+**height**
+
+The height of the renderer.
+
+## Type Definitions
+
+### .Parameters
+
+Constructor parameters of `CSS3DRenderer`.
+
+**element**
+HTMLElement
+
+A DOM element where the renderer appends its child-elements. If not passed in here, a new div element will be created.
+
+## Source
+
+[examples/jsm/renderers/CSS3DRenderer.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/renderers/CSS3DRenderer.js)
\ No newline at end of file
diff --git a/docs/pages/CSS3DSprite.html.md b/docs/pages/CSS3DSprite.html.md
new file mode 100644
index 00000000000000..e1021880f176a8
--- /dev/null
+++ b/docs/pages/CSS3DSprite.html.md
@@ -0,0 +1,41 @@
+*Inheritance: EventDispatcher → Object3D → CSS3DObject →*
+
+# CSS3DSprite
+
+A specialized version of [CSS3DObject](CSS3DObject.html) that represents DOM elements as sprites.
+
+## Import
+
+CSS3DSprite is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { CSS3DSprite } from 'three/addons/renderers/CSS3DRenderer.js';
+```
+
+## Constructor
+
+### new CSS3DSprite( element : HTMLElement )
+
+Constructs a new CSS3D sprite object.
+
+**element**
+
+The DOM element.
+
+## Properties
+
+### .isCSS3DSprite : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .rotation2D : number
+
+The sprite's rotation in radians.
+
+Default is `0`.
+
+## Source
+
+[examples/jsm/renderers/CSS3DRenderer.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/renderers/CSS3DRenderer.js)
\ No newline at end of file
diff --git a/docs/pages/Cache.html.md b/docs/pages/Cache.html.md
new file mode 100644
index 00000000000000..e07912080bca14
--- /dev/null
+++ b/docs/pages/Cache.html.md
@@ -0,0 +1,55 @@
+# Cache
+
+A simple caching system, used internally by [FileLoader](FileLoader.html). To enable caching across all loaders that use [FileLoader](FileLoader.html), add `THREE.Cache.enabled = true.` once in your app.
+
+## Properties
+
+### .enabled : boolean
+
+Whether caching is enabled or not.
+
+Default is `false`.
+
+### .files : Object.
+
+A dictionary that holds cached files.
+
+## Static Methods
+
+### .add( key : string, file : Object )
+
+Adds a cache entry with a key to reference the file. If this key already holds a file, it is overwritten.
+
+**key**
+
+The key to reference the cached file.
+
+**file**
+
+The file to be cached.
+
+### .clear()
+
+Remove all values from the cache.
+
+### .get( key : string ) : Object | undefined
+
+Gets the cached value for the given key.
+
+**key**
+
+The key to reference the cached file.
+
+**Returns:** The cached file. If the key does not exist `undefined` is returned.
+
+### .remove( key : string )
+
+Removes the cached file associated with the given key.
+
+**key**
+
+The key to reference the cached file.
+
+## Source
+
+[src/loaders/Cache.js](https://github.com/mrdoob/three.js/blob/master/src/loaders/Cache.js)
\ No newline at end of file
diff --git a/docs/pages/Camera.html.md b/docs/pages/Camera.html.md
new file mode 100644
index 00000000000000..ba2ef91a4a86ac
--- /dev/null
+++ b/docs/pages/Camera.html.md
@@ -0,0 +1,61 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# Camera
+
+Abstract base class for cameras. This class should always be inherited when you build a new camera.
+
+## Constructor
+
+### new Camera() (abstract)
+
+Constructs a new camera.
+
+## Properties
+
+### .coordinateSystem : WebGLCoordinateSystem | WebGPUCoordinateSystem
+
+The coordinate system in which the camera is used.
+
+### .isCamera : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .matrixWorldInverse : Matrix4
+
+The inverse of the camera's world matrix.
+
+### .projectionMatrix : Matrix4
+
+The camera's projection matrix.
+
+### .projectionMatrixInverse : Matrix4
+
+The inverse of the camera's projection matrix.
+
+### .reversedDepth : boolean
+
+The flag that indicates whether the camera uses a reversed depth buffer.
+
+Default is `false`.
+
+## Methods
+
+### .getWorldDirection( target : Vector3 ) : Vector3
+
+Returns a vector representing the ("look") direction of the 3D object in world space.
+
+This method is overwritten since cameras have a different forward vector compared to other 3D objects. A camera looks down its local, negative z-axis by default.
+
+**target**
+
+The target vector the result is stored to.
+
+**Overrides:** [Object3D#getWorldDirection](Object3D.html#getWorldDirection)
+
+**Returns:** The 3D object's direction in world space.
+
+## Source
+
+[src/cameras/Camera.js](https://github.com/mrdoob/three.js/blob/master/src/cameras/Camera.js)
\ No newline at end of file
diff --git a/docs/pages/CameraHelper.html.md b/docs/pages/CameraHelper.html.md
new file mode 100644
index 00000000000000..3bcba112516227
--- /dev/null
+++ b/docs/pages/CameraHelper.html.md
@@ -0,0 +1,77 @@
+*Inheritance: EventDispatcher → Object3D → Line → LineSegments →*
+
+# CameraHelper
+
+This helps with visualizing what a camera contains in its frustum. It visualizes the frustum of a camera using a line segments.
+
+Based on frustum visualization in [lightgl.js shadowmap example](https://github.com/evanw/lightgl.js/blob/master/tests/shadowmap.html).
+
+`CameraHelper` must be a child of the scene.
+
+## Code Example
+
+```js
+const camera = new THREE.PerspectiveCamera( 75, window.innerWidth / window.innerHeight, 0.1, 1000 );
+const helper = new THREE.CameraHelper( camera );
+scene.add( helper );
+```
+
+## Constructor
+
+### new CameraHelper( camera : Camera )
+
+Constructs a new arrow helper.
+
+**camera**
+
+The camera to visualize.
+
+## Properties
+
+### .camera : Camera
+
+The camera being visualized.
+
+### .pointMap : Object.>
+
+This contains the points used to visualize the camera.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+### .setColors( frustum : Color, cone : Color, up : Color, target : Color, cross : Color ) : CameraHelper
+
+Defines the colors of the helper.
+
+**frustum**
+
+The frustum line color.
+
+**cone**
+
+The cone line color.
+
+**up**
+
+The up line color.
+
+**target**
+
+The target line color.
+
+**cross**
+
+The cross line color.
+
+**Returns:** A reference to this helper.
+
+### .update()
+
+Updates the helper based on the projection matrix of the camera.
+
+## Source
+
+[src/helpers/CameraHelper.js](https://github.com/mrdoob/three.js/blob/master/src/helpers/CameraHelper.js)
\ No newline at end of file
diff --git a/docs/pages/CanvasTarget.html.md b/docs/pages/CanvasTarget.html.md
new file mode 100644
index 00000000000000..f166ef5c6fd5f1
--- /dev/null
+++ b/docs/pages/CanvasTarget.html.md
@@ -0,0 +1,204 @@
+*Inheritance: EventDispatcher →*
+
+# CanvasTarget
+
+CanvasTarget is a class that represents the final output destination of the renderer.
+
+## Constructor
+
+### new CanvasTarget( domElement : HTMLCanvasElement | OffscreenCanvas )
+
+Constructs a new CanvasTarget.
+
+**domElement**
+
+The canvas element to render to.
+
+## Properties
+
+### .colorTexture : FramebufferTexture
+
+The color texture of the default framebuffer.
+
+### .depthTexture : DepthTexture
+
+The depth texture of the default framebuffer.
+
+### .domElement : HTMLCanvasElement | OffscreenCanvas
+
+A reference to the canvas element the renderer is drawing to. This value of this property will automatically be created by the renderer.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+##### Fires:
+
+* RenderTarget#event:dispose
+
+### .getDrawingBufferSize( target : Vector2 ) : Vector2
+
+Returns the drawing buffer size in physical pixels. This method honors the pixel ratio.
+
+**target**
+
+The method writes the result in this target object.
+
+**Returns:** The drawing buffer size.
+
+### .getPixelRatio() : number
+
+Returns the pixel ratio.
+
+**Returns:** The pixel ratio.
+
+### .getScissor( target : Vector4 ) : Vector4
+
+Returns the scissor rectangle.
+
+**target**
+
+The method writes the result in this target object.
+
+**Returns:** The scissor rectangle.
+
+### .getScissorTest() : boolean
+
+Returns the scissor test value.
+
+**Returns:** Whether the scissor test should be enabled or not.
+
+### .getSize( target : Vector2 ) : Vector2
+
+Returns the renderer's size in logical pixels. This method does not honor the pixel ratio.
+
+**target**
+
+The method writes the result in this target object.
+
+**Returns:** The renderer's size in logical pixels.
+
+### .getViewport( target : Vector4 ) : Vector4
+
+Returns the viewport definition.
+
+**target**
+
+The method writes the result in this target object.
+
+**Returns:** The viewport definition.
+
+### .setDrawingBufferSize( width : number, height : number, pixelRatio : number )
+
+This method allows to define the drawing buffer size by specifying width, height and pixel ratio all at once. The size of the drawing buffer is computed with this formula:
+
+```js
+size.x = width * pixelRatio;
+size.y = height * pixelRatio;
+```
+
+**width**
+
+The width in logical pixels.
+
+**height**
+
+The height in logical pixels.
+
+**pixelRatio**
+
+The pixel ratio.
+
+### .setPixelRatio( value : number )
+
+Sets the given pixel ratio and resizes the canvas if necessary.
+
+**value**
+
+The pixel ratio.
+
+Default is `1`.
+
+### .setScissor( x : number | Vector4, y : number, width : number, height : number )
+
+Defines the scissor rectangle.
+
+**x**
+
+The horizontal coordinate for the lower left corner of the box in logical pixel unit. Instead of passing four arguments, the method also works with a single four-dimensional vector.
+
+**y**
+
+The vertical coordinate for the lower left corner of the box in logical pixel unit.
+
+**width**
+
+The width of the scissor box in logical pixel unit.
+
+**height**
+
+The height of the scissor box in logical pixel unit.
+
+### .setScissorTest( boolean : boolean )
+
+Defines the scissor test.
+
+**boolean**
+
+Whether the scissor test should be enabled or not.
+
+### .setSize( width : number, height : number, updateStyle : boolean )
+
+Sets the size of the renderer.
+
+**width**
+
+The width in logical pixels.
+
+**height**
+
+The height in logical pixels.
+
+**updateStyle**
+
+Whether to update the `style` attribute of the canvas or not.
+
+Default is `true`.
+
+### .setViewport( x : number | Vector4, y : number, width : number, height : number, minDepth : number, maxDepth : number )
+
+Defines the viewport.
+
+**x**
+
+The horizontal coordinate for the lower left corner of the viewport origin in logical pixel unit.
+
+**y**
+
+The vertical coordinate for the lower left corner of the viewport origin in logical pixel unit.
+
+**width**
+
+The width of the viewport in logical pixel unit.
+
+**height**
+
+The height of the viewport in logical pixel unit.
+
+**minDepth**
+
+The minimum depth value of the viewport. WebGPU only.
+
+Default is `0`.
+
+**maxDepth**
+
+The maximum depth value of the viewport. WebGPU only.
+
+Default is `1`.
+
+## Source
+
+[src/renderers/common/CanvasTarget.js](https://github.com/mrdoob/three.js/blob/master/src/renderers/common/CanvasTarget.js)
\ No newline at end of file
diff --git a/docs/pages/CanvasTexture.html.md b/docs/pages/CanvasTexture.html.md
new file mode 100644
index 00000000000000..c3a4ad7609a778
--- /dev/null
+++ b/docs/pages/CanvasTexture.html.md
@@ -0,0 +1,77 @@
+*Inheritance: EventDispatcher → Texture →*
+
+# CanvasTexture
+
+Creates a texture from a canvas element.
+
+This is almost the same as the base texture class, except that it sets [Texture#needsUpdate](Texture.html#needsUpdate) to `true` immediately since a canvas can directly be used for rendering.
+
+## Constructor
+
+### new CanvasTexture( canvas : HTMLCanvasElement, mapping : number, wrapS : number, wrapT : number, magFilter : number, minFilter : number, format : number, type : number, anisotropy : number )
+
+Constructs a new texture.
+
+**canvas**
+
+The HTML canvas element.
+
+**mapping**
+
+The texture mapping.
+
+Default is `Texture.DEFAULT_MAPPING`.
+
+**wrapS**
+
+The wrapS value.
+
+Default is `ClampToEdgeWrapping`.
+
+**wrapT**
+
+The wrapT value.
+
+Default is `ClampToEdgeWrapping`.
+
+**magFilter**
+
+The mag filter value.
+
+Default is `LinearFilter`.
+
+**minFilter**
+
+The min filter value.
+
+Default is `LinearMipmapLinearFilter`.
+
+**format**
+
+The texture format.
+
+Default is `RGBAFormat`.
+
+**type**
+
+The texture type.
+
+Default is `UnsignedByteType`.
+
+**anisotropy**
+
+The anisotropy value.
+
+Default is `Texture.DEFAULT_ANISOTROPY`.
+
+## Properties
+
+### .isCanvasTexture : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/textures/CanvasTexture.js](https://github.com/mrdoob/three.js/blob/master/src/textures/CanvasTexture.js)
\ No newline at end of file
diff --git a/docs/pages/Capsule.html.md b/docs/pages/Capsule.html.md
new file mode 100644
index 00000000000000..883c16056d1569
--- /dev/null
+++ b/docs/pages/Capsule.html.md
@@ -0,0 +1,119 @@
+# Capsule
+
+A capsule is essentially a cylinder with hemispherical caps at both ends. It can be thought of as a swept sphere, where a sphere is moved along a line segment.
+
+Capsules are often used as bounding volumes (next to AABBs and bounding spheres).
+
+## Import
+
+Capsule is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { Capsule } from 'three/addons/math/Capsule.js';
+```
+
+## Constructor
+
+### new Capsule( start : Vector3, end : Vector3, radius : number )
+
+Constructs a new capsule.
+
+**start**
+
+The start vector.
+
+**end**
+
+The end vector.
+
+**radius**
+
+The capsule's radius.
+
+Default is `1`.
+
+## Properties
+
+### .end : Vector3
+
+The end vector.
+
+### .radius : number
+
+The capsule's radius.
+
+Default is `1`.
+
+### .start : Vector3
+
+The start vector.
+
+## Methods
+
+### .clone() : Capsule
+
+Returns a new capsule with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .copy( capsule : Capsule ) : Capsule
+
+Copies the values of the given capsule to this instance.
+
+**capsule**
+
+The capsule to copy.
+
+**Returns:** A reference to this capsule.
+
+### .getCenter( target : Vector3 ) : Vector3
+
+Returns the center point of this capsule.
+
+**target**
+
+The target vector that is used to store the method's result.
+
+**Returns:** The center point.
+
+### .intersectsBox( box : Box3 ) : boolean
+
+Returns `true` if the given bounding box intersects with this capsule.
+
+**box**
+
+The bounding box to test.
+
+**Returns:** Whether the given bounding box intersects with this capsule.
+
+### .set( start : Vector3, end : Vector3, radius : number ) : Capsule
+
+Sets the capsule components to the given values. Please note that this method only copies the values from the given objects.
+
+**start**
+
+The start vector.
+
+**end**
+
+The end vector
+
+**radius**
+
+The capsule's radius.
+
+**Returns:** A reference to this capsule.
+
+### .translate( v : Vector3 ) : Capsule
+
+Adds the given offset to this capsule, effectively moving it in 3D space.
+
+**v**
+
+The offset that should be used to translate the capsule.
+
+**Returns:** A reference to this capsule.
+
+## Source
+
+[examples/jsm/math/Capsule.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/math/Capsule.js)
\ No newline at end of file
diff --git a/docs/pages/CapsuleGeometry.html.md b/docs/pages/CapsuleGeometry.html.md
new file mode 100644
index 00000000000000..3f5d7a88facab0
--- /dev/null
+++ b/docs/pages/CapsuleGeometry.html.md
@@ -0,0 +1,72 @@
+*Inheritance: EventDispatcher → BufferGeometry →*
+
+# CapsuleGeometry
+
+A geometry class for representing a capsule.
+
+## Code Example
+
+```js
+const geometry = new THREE.CapsuleGeometry( 1, 1, 4, 8, 1 );
+const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
+const capsule = new THREE.Mesh( geometry, material );
+scene.add( capsule );
+```
+
+## Constructor
+
+### new CapsuleGeometry( radius : number, height : number, capSegments : number, radialSegments : number, heightSegments : number )
+
+Constructs a new capsule geometry.
+
+**radius**
+
+Radius of the capsule.
+
+Default is `1`.
+
+**height**
+
+Height of the middle section.
+
+Default is `1`.
+
+**capSegments**
+
+Number of curve segments used to build each cap.
+
+Default is `4`.
+
+**radialSegments**
+
+Number of segmented faces around the circumference of the capsule. Must be an integer >= 3.
+
+Default is `8`.
+
+**heightSegments**
+
+Number of rows of faces along the height of the middle section. Must be an integer >= 1.
+
+Default is `1`.
+
+## Properties
+
+### .parameters : Object
+
+Holds the constructor parameters that have been used to generate the geometry. Any modification after instantiation does not change the geometry.
+
+## Static Methods
+
+### .fromJSON( data : Object ) : CapsuleGeometry
+
+Factory method for creating an instance of this class from the given JSON object.
+
+**data**
+
+A JSON object representing the serialized geometry.
+
+**Returns:** A new instance.
+
+## Source
+
+[src/geometries/CapsuleGeometry.js](https://github.com/mrdoob/three.js/blob/master/src/geometries/CapsuleGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/CatmullRomCurve3.html.md b/docs/pages/CatmullRomCurve3.html.md
new file mode 100644
index 00000000000000..b6cbda73eab88b
--- /dev/null
+++ b/docs/pages/CatmullRomCurve3.html.md
@@ -0,0 +1,103 @@
+*Inheritance: Curve →*
+
+# CatmullRomCurve3
+
+A curve representing a Catmull-Rom spline.
+
+## Code Example
+
+```js
+//Create a closed wavey loop
+const curve = new THREE.CatmullRomCurve3( [
+ new THREE.Vector3( -10, 0, 10 ),
+ new THREE.Vector3( -5, 5, 5 ),
+ new THREE.Vector3( 0, 0, 0 ),
+ new THREE.Vector3( 5, -5, 5 ),
+ new THREE.Vector3( 10, 0, 10 )
+] );
+const points = curve.getPoints( 50 );
+const geometry = new THREE.BufferGeometry().setFromPoints( points );
+const material = new THREE.LineBasicMaterial( { color: 0xff0000 } );
+// Create the final object to add to the scene
+const curveObject = new THREE.Line( geometry, material );
+```
+
+## Constructor
+
+### new CatmullRomCurve3( points : Array., closed : boolean, curveType : 'centripetal' | 'chordal' | 'catmullrom', tension : number )
+
+Constructs a new Catmull-Rom curve.
+
+**points**
+
+An array of 3D points defining the curve.
+
+**closed**
+
+Whether the curve is closed or not.
+
+Default is `false`.
+
+**curveType**
+
+The curve type.
+
+Default is `'centripetal'`.
+
+**tension**
+
+Tension of the curve.
+
+Default is `0.5`.
+
+## Properties
+
+### .closed : boolean
+
+Whether the curve is closed or not.
+
+Default is `false`.
+
+### .curveType : 'centripetal' | 'chordal' | 'catmullrom'
+
+The curve type.
+
+Default is `'centripetal'`.
+
+### .isCatmullRomCurve3 : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .points : Array.
+
+An array of 3D points defining the curve.
+
+### .tension : number
+
+Tension of the curve.
+
+Default is `0.5`.
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector3 ) : Vector3
+
+Returns a point on the curve.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve.
+
+## Source
+
+[src/extras/curves/CatmullRomCurve3.js](https://github.com/mrdoob/three.js/blob/master/src/extras/curves/CatmullRomCurve3.js)
\ No newline at end of file
diff --git a/docs/pages/ChromaticAberrationNode.html.md b/docs/pages/ChromaticAberrationNode.html.md
new file mode 100644
index 00000000000000..f11218280d1f92
--- /dev/null
+++ b/docs/pages/ChromaticAberrationNode.html.md
@@ -0,0 +1,87 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# ChromaticAberrationNode
+
+Post processing node for applying chromatic aberration effect. This effect simulates the color fringing that occurs in real camera lenses by separating and offsetting the red, green, and blue channels.
+
+## Import
+
+ChromaticAberrationNode is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { chromaticAberration } from 'three/addons/tsl/display/ChromaticAberrationNode.js';
+```
+
+## Constructor
+
+### new ChromaticAberrationNode( textureNode : TextureNode, strengthNode : Node, centerNode : Node, scaleNode : Node )
+
+Constructs a new chromatic aberration node.
+
+**textureNode**
+
+The texture node that represents the input of the effect.
+
+**strengthNode**
+
+The strength of the chromatic aberration effect as a node.
+
+**centerNode**
+
+The center point of the effect as a node.
+
+**scaleNode**
+
+The scale factor for stepped scaling from center as a node.
+
+## Properties
+
+### .centerNode : Node
+
+A node holding the center point of the effect.
+
+### .scaleNode : Node
+
+A node holding the scale factor for stepped scaling.
+
+### .strengthNode : Node
+
+A node holding the strength of the effect.
+
+### .textureNode : texture
+
+The texture node that represents the input of the effect.
+
+### .updateBeforeType : string
+
+The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node updates its internal uniforms once per frame in `updateBefore()`.
+
+Default is `'frame'`.
+
+**Overrides:** [TempNode#updateBeforeType](TempNode.html#updateBeforeType)
+
+## Methods
+
+### .setup( builder : NodeBuilder ) : ShaderCallNodeInternal
+
+This method is used to setup the effect's TSL code.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#setup](TempNode.html#setup)
+
+### .updateBefore( frame : NodeFrame )
+
+This method is used to update the effect's uniforms once per frame.
+
+**frame**
+
+The current node frame.
+
+**Overrides:** [TempNode#updateBefore](TempNode.html#updateBefore)
+
+## Source
+
+[examples/jsm/tsl/display/ChromaticAberrationNode.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/tsl/display/ChromaticAberrationNode.js)
\ No newline at end of file
diff --git a/docs/pages/CinquefoilKnot.html.md b/docs/pages/CinquefoilKnot.html.md
new file mode 100644
index 00000000000000..259cbfa8ba5867
--- /dev/null
+++ b/docs/pages/CinquefoilKnot.html.md
@@ -0,0 +1,55 @@
+*Inheritance: Curve →*
+
+# CinquefoilKnot
+
+A Cinquefoil Knot.
+
+## Import
+
+CinquefoilKnot is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { CinquefoilKnot } from 'three/addons/curves/CurveExtras.js';
+```
+
+## Constructor
+
+### new CinquefoilKnot( scale : number )
+
+Constructs a new Cinquefoil Knot.
+
+**scale**
+
+The curve's scale.
+
+Default is `10`.
+
+## Properties
+
+### .scale : number
+
+The curve's scale.
+
+Default is `10`.
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector3 ) : Vector3
+
+This method returns a vector in 3D space for the given interpolation factor.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve.
+
+## Source
+
+[examples/jsm/curves/CurveExtras.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/curves/CurveExtras.js)
\ No newline at end of file
diff --git a/docs/pages/CircleGeometry.html.md b/docs/pages/CircleGeometry.html.md
new file mode 100644
index 00000000000000..1480b407a1c997
--- /dev/null
+++ b/docs/pages/CircleGeometry.html.md
@@ -0,0 +1,66 @@
+*Inheritance: EventDispatcher → BufferGeometry →*
+
+# CircleGeometry
+
+A simple shape of Euclidean geometry. It is constructed from a number of triangular segments that are oriented around a central point and extend as far out as a given radius. It is built counter-clockwise from a start angle and a given central angle. It can also be used to create regular polygons, where the number of segments determines the number of sides.
+
+## Code Example
+
+```js
+const geometry = new THREE.CircleGeometry( 5, 32 );
+const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
+const circle = new THREE.Mesh( geometry, material );
+scene.add( circle )
+```
+
+## Constructor
+
+### new CircleGeometry( radius : number, segments : number, thetaStart : number, thetaLength : number )
+
+Constructs a new circle geometry.
+
+**radius**
+
+Radius of the circle.
+
+Default is `1`.
+
+**segments**
+
+Number of segments (triangles), minimum = `3`.
+
+Default is `32`.
+
+**thetaStart**
+
+Start angle for first segment in radians.
+
+Default is `0`.
+
+**thetaLength**
+
+The central angle, often called theta, of the circular sector in radians. The default value results in a complete circle.
+
+Default is `Math.PI*2`.
+
+## Properties
+
+### .parameters : Object
+
+Holds the constructor parameters that have been used to generate the geometry. Any modification after instantiation does not change the geometry.
+
+## Static Methods
+
+### .fromJSON( data : Object ) : CircleGeometry
+
+Factory method for creating an instance of this class from the given JSON object.
+
+**data**
+
+A JSON object representing the serialized geometry.
+
+**Returns:** A new instance.
+
+## Source
+
+[src/geometries/CircleGeometry.js](https://github.com/mrdoob/three.js/blob/master/src/geometries/CircleGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/ClearMaskPass.html.md b/docs/pages/ClearMaskPass.html.md
new file mode 100644
index 00000000000000..53032c04fdd53d
--- /dev/null
+++ b/docs/pages/ClearMaskPass.html.md
@@ -0,0 +1,60 @@
+*Inheritance: Pass →*
+
+# ClearMaskPass
+
+This pass can be used to clear a mask previously defined with [MaskPass](MaskPass.html).
+
+## Code Example
+
+```js
+const clearPass = new ClearMaskPass();
+composer.addPass( clearPass );
+```
+
+## Constructor
+
+### new ClearMaskPass()
+
+Constructs a new clear mask pass.
+
+## Properties
+
+### .needsSwap : boolean
+
+Overwritten to disable the swap.
+
+Default is `false`.
+
+**Overrides:** [Pass#needsSwap](Pass.html#needsSwap)
+
+## Methods
+
+### .render( renderer : WebGLRenderer, writeBuffer : WebGLRenderTarget, readBuffer : WebGLRenderTarget, deltaTime : number, maskActive : boolean )
+
+Performs the clear of the currently defined mask.
+
+**renderer**
+
+The renderer.
+
+**writeBuffer**
+
+The write buffer. This buffer is intended as the rendering destination for the pass.
+
+**readBuffer**
+
+The read buffer. The pass can access the result from the previous pass from this buffer.
+
+**deltaTime**
+
+The delta time in seconds.
+
+**maskActive**
+
+Whether masking is active or not.
+
+**Overrides:** [Pass#render](Pass.html#render)
+
+## Source
+
+[examples/jsm/postprocessing/MaskPass.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/MaskPass.js)
\ No newline at end of file
diff --git a/docs/pages/ClearPass.html.md b/docs/pages/ClearPass.html.md
new file mode 100644
index 00000000000000..36e338e8eebdcb
--- /dev/null
+++ b/docs/pages/ClearPass.html.md
@@ -0,0 +1,92 @@
+*Inheritance: Pass →*
+
+# ClearPass
+
+This class can be used to force a clear operation for the current read or default framebuffer (when rendering to screen).
+
+## Code Example
+
+```js
+const clearPass = new ClearPass();
+composer.addPass( clearPass );
+```
+
+## Import
+
+ClearPass is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { ClearPass } from 'three/addons/postprocessing/ClearPass.js';
+```
+
+## Constructor
+
+### new ClearPass( clearColor : number | Color | string, clearAlpha : number )
+
+Constructs a new clear pass.
+
+**clearColor**
+
+The clear color.
+
+Default is `0x000000`.
+
+**clearAlpha**
+
+The clear alpha.
+
+Default is `0`.
+
+## Properties
+
+### .clearAlpha : number
+
+The clear alpha.
+
+Default is `0`.
+
+### .clearColor : number | Color | string
+
+The clear color.
+
+Default is `0x000000`.
+
+### .needsSwap : boolean
+
+Overwritten to disable the swap.
+
+Default is `false`.
+
+**Overrides:** [Pass#needsSwap](Pass.html#needsSwap)
+
+## Methods
+
+### .render( renderer : WebGLRenderer, writeBuffer : WebGLRenderTarget, readBuffer : WebGLRenderTarget, deltaTime : number, maskActive : boolean )
+
+Performs the clear operation. This affects the current read or the default framebuffer.
+
+**renderer**
+
+The renderer.
+
+**writeBuffer**
+
+The write buffer. This buffer is intended as the rendering destination for the pass.
+
+**readBuffer**
+
+The read buffer. The pass can access the result from the previous pass from this buffer.
+
+**deltaTime**
+
+The delta time in seconds.
+
+**maskActive**
+
+Whether masking is active or not.
+
+**Overrides:** [Pass#render](Pass.html#render)
+
+## Source
+
+[examples/jsm/postprocessing/ClearPass.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/ClearPass.js)
\ No newline at end of file
diff --git a/docs/pages/ClippingGroup.html.md b/docs/pages/ClippingGroup.html.md
new file mode 100644
index 00000000000000..18f6fc069fb285
--- /dev/null
+++ b/docs/pages/ClippingGroup.html.md
@@ -0,0 +1,47 @@
+*Inheritance: EventDispatcher → Object3D → Group →*
+
+# ClippingGroup
+
+In earlier three.js versions, clipping was defined globally on the renderer or on material level. This special version of `THREE.Group` allows to encode the clipping state into the scene graph. Meaning if you create an instance of this group, all descendant 3D objects will be affected by the respective clipping planes.
+
+Note: `ClippingGroup` can only be used with `WebGPURenderer`.
+
+## Constructor
+
+### new ClippingGroup()
+
+Constructs a new clipping group.
+
+## Properties
+
+### .clipIntersection : boolean
+
+Whether the intersection of the clipping planes is used to clip objects, rather than their union.
+
+Default is `false`.
+
+### .clipShadows : boolean
+
+Whether shadows should be clipped or not.
+
+Default is `false`.
+
+### .clippingPlanes : Array.
+
+An array with clipping planes.
+
+### .enabled : boolean
+
+Whether clipping should be enabled or not.
+
+Default is `true`.
+
+### .isClippingGroup : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/objects/ClippingGroup.js](https://github.com/mrdoob/three.js/blob/master/src/objects/ClippingGroup.js)
\ No newline at end of file
diff --git a/docs/pages/ClippingNode.html.md b/docs/pages/ClippingNode.html.md
new file mode 100644
index 00000000000000..695db7540cbb5c
--- /dev/null
+++ b/docs/pages/ClippingNode.html.md
@@ -0,0 +1,83 @@
+*Inheritance: EventDispatcher → Node →*
+
+# ClippingNode
+
+This node is used in [NodeMaterial](NodeMaterial.html) to setup the clipping which can happen hardware-accelerated (if supported) and optionally use alpha-to-coverage for anti-aliasing clipped edges.
+
+## Constructor
+
+### new ClippingNode( scope : 'default' | 'hardware' | 'alphaToCoverage' )
+
+Constructs a new clipping node.
+
+**scope**
+
+The node's scope. Similar to other nodes, the selected scope influences the behavior of the node and what type of code is generated.
+
+Default is `'default'`.
+
+## Properties
+
+### .scope : 'default' | 'hardware' | 'alphaToCoverage'
+
+The node's scope. Similar to other nodes, the selected scope influences the behavior of the node and what type of code is generated.
+
+## Methods
+
+### .setup( builder : NodeBuilder ) : Node
+
+Setups the node depending on the selected scope.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [Node#setup](Node.html#setup)
+
+**Returns:** The result node.
+
+### .setupAlphaToCoverage( intersectionPlanes : Array., unionPlanes : Array. ) : Node
+
+Setups alpha to coverage.
+
+**intersectionPlanes**
+
+The intersection planes.
+
+**unionPlanes**
+
+The union planes.
+
+**Returns:** The result node.
+
+### .setupDefault( intersectionPlanes : Array., unionPlanes : Array. ) : Node
+
+Setups the default clipping.
+
+**intersectionPlanes**
+
+The intersection planes.
+
+**unionPlanes**
+
+The union planes.
+
+**Returns:** The result node.
+
+### .setupHardwareClipping( unionPlanes : Array., builder : NodeBuilder ) : Node
+
+Setups hardware clipping.
+
+**unionPlanes**
+
+The union planes.
+
+**builder**
+
+The current node builder.
+
+**Returns:** The result node.
+
+## Source
+
+[src/nodes/accessors/ClippingNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/accessors/ClippingNode.js)
\ No newline at end of file
diff --git a/docs/pages/Clock.html.md b/docs/pages/Clock.html.md
new file mode 100644
index 00000000000000..d18bad81e5e5ac
--- /dev/null
+++ b/docs/pages/Clock.html.md
@@ -0,0 +1,73 @@
+# Clock
+
+Class for keeping track of time.
+
+## Constructor
+
+### new Clock( autoStart : boolean )
+
+Constructs a new clock.
+
+**autoStart**
+
+Whether to automatically start the clock when `getDelta()` is called for the first time.
+
+Default is `true`.
+
+## Properties
+
+### .autoStart : boolean
+
+If set to `true`, the clock starts automatically when `getDelta()` is called for the first time.
+
+Default is `true`.
+
+### .elapsedTime : number
+
+Keeps track of the total time that the clock has been running.
+
+Default is `0`.
+
+### .oldTime : number
+
+Holds the time at which the clock's `start()`, `getElapsedTime()` or `getDelta()` methods were last called.
+
+Default is `0`.
+
+### .running : boolean
+
+Whether the clock is running or not.
+
+Default is `true`.
+
+### .startTime : number
+
+Holds the time at which the clock's `start()` method was last called.
+
+Default is `0`.
+
+## Methods
+
+### .getDelta() : number
+
+Returns the delta time in seconds.
+
+**Returns:** The delta time.
+
+### .getElapsedTime() : number
+
+Returns the elapsed time in seconds.
+
+**Returns:** The elapsed time.
+
+### .start()
+
+Starts the clock. When `autoStart` is set to `true`, the method is automatically called by the class.
+
+### .stop()
+
+Stops the clock.
+
+## Source
+
+[src/core/Clock.js](https://github.com/mrdoob/three.js/blob/master/src/core/Clock.js)
\ No newline at end of file
diff --git a/docs/pages/CodeNode.html.md b/docs/pages/CodeNode.html.md
new file mode 100644
index 00000000000000..6c094e2199d789
--- /dev/null
+++ b/docs/pages/CodeNode.html.md
@@ -0,0 +1,89 @@
+*Inheritance: EventDispatcher → Node →*
+
+# CodeNode
+
+This class represents native code sections. It is the base class for modules like [FunctionNode](FunctionNode.html) which allows to implement functions with native shader languages.
+
+## Constructor
+
+### new CodeNode( code : string, includes : Array., language : 'js' | 'wgsl' | 'glsl' )
+
+Constructs a new code node.
+
+**code**
+
+The native code.
+
+Default is `''`.
+
+**includes**
+
+An array of includes.
+
+Default is `[]`.
+
+**language**
+
+The used language.
+
+Default is `''`.
+
+## Properties
+
+### .code : string
+
+The native code.
+
+Default is `''`.
+
+### .global : boolean
+
+This flag is used for global cache.
+
+Default is `true`.
+
+**Overrides:** [Node#global](Node.html#global)
+
+### .includes : Array.
+
+An array of includes
+
+Default is `[]`.
+
+### .isCodeNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .language : 'js' | 'wgsl' | 'glsl'
+
+The used language.
+
+Default is `''`.
+
+## Methods
+
+### .getIncludes( builder : NodeBuilder ) : Array.
+
+Returns the includes of this code node.
+
+**builder**
+
+The current node builder.
+
+**Returns:** The includes.
+
+### .setIncludes( includes : Array. ) : CodeNode
+
+Sets the includes of this code node.
+
+**includes**
+
+The includes to set.
+
+**Returns:** A reference to this node.
+
+## Source
+
+[src/nodes/code/CodeNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/code/CodeNode.js)
\ No newline at end of file
diff --git a/docs/pages/ColladaLoader.html.md b/docs/pages/ColladaLoader.html.md
new file mode 100644
index 00000000000000..cd0281e2f3e214
--- /dev/null
+++ b/docs/pages/ColladaLoader.html.md
@@ -0,0 +1,73 @@
+*Inheritance: Loader →*
+
+# ColladaLoader
+
+A loader for the Collada format.
+
+The Collada format is very complex so this loader only supports a subset of what is defined in the [official specification](https://www.khronos.org/files/collada_spec_1_5.pdf).
+
+Assets with a Z-UP coordinate system are transformed it into Y-UP by a simple rotation. The vertex data are not converted.
+
+## Code Example
+
+```js
+const loader = new ColladaLoader();
+const result = await loader.loadAsync( './models/collada/elf/elf.dae' );
+scene.add( result.scene );
+```
+
+## Import
+
+ColladaLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { ColladaLoader } from 'three/addons/loaders/ColladaLoader.js';
+```
+
+## Constructor
+
+### new ColladaLoader()
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded Collada asset to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( text : string, path : string ) : Object
+
+Parses the given Collada data and returns a result object holding the parsed scene, an array of animation clips and kinematics.
+
+**text**
+
+The raw Collada data as a string.
+
+**path**
+
+The asset path.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** An object representing the parsed asset.
+
+## Source
+
+[examples/jsm/loaders/ColladaLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/ColladaLoader.js)
\ No newline at end of file
diff --git a/docs/pages/Color.html.md b/docs/pages/Color.html.md
new file mode 100644
index 00000000000000..dd2a85d5ad1260
--- /dev/null
+++ b/docs/pages/Color.html.md
@@ -0,0 +1,554 @@
+# Color
+
+A Color instance is represented by RGB components in the linear _working color space_, which defaults to `LinearSRGBColorSpace`. Inputs conventionally using `SRGBColorSpace` (such as hexadecimals and CSS strings) are converted to the working color space automatically.
+
+Source color spaces may be specified explicitly, to ensure correct conversions.
+
+```js
+// assumed already LinearSRGBColorSpace; no conversion
+const color = new THREE.Color().setRGB( 0.5, 0.5, 0.5 );
+// converted explicitly from SRGBColorSpace to LinearSRGBColorSpace
+const color = new THREE.Color().setRGB( 0.5, 0.5, 0.5, SRGBColorSpace );
+```
+
+If THREE.ColorManagement is disabled, no conversions occur. For details, see _Color management_. Iterating through a Color instance will yield its components (r, g, b) in the corresponding order. A Color can be initialised in any of the following ways:
+
+```js
+//empty constructor - will default white
+const color1 = new THREE.Color();
+//Hexadecimal color (recommended)
+const color2 = new THREE.Color( 0xff0000 );
+//RGB string
+const color3 = new THREE.Color("rgb(255, 0, 0)");
+const color4 = new THREE.Color("rgb(100%, 0%, 0%)");
+//X11 color name - all 140 color names are supported.
+//Note the lack of CamelCase in the name
+const color5 = new THREE.Color( 'skyblue' );
+//HSL string
+const color6 = new THREE.Color("hsl(0, 100%, 50%)");
+//Separate RGB values between 0 and 1
+const color7 = new THREE.Color( 1, 0, 0 );
+```
+
+## Code Example
+
+```js
+// converted automatically from SRGBColorSpace to LinearSRGBColorSpace
+const color = new THREE.Color().setHex( 0x112233 );
+```
+
+## Constructor
+
+### new Color( r : number | string | Color, g : number, b : number )
+
+Constructs a new color.
+
+Note that standard method of specifying color in three.js is with a hexadecimal triplet, and that method is used throughout the rest of the documentation.
+
+**r**
+
+The red component of the color. If `g` and `b` are not provided, it can be hexadecimal triplet, a CSS-style string or another `Color` instance.
+
+**g**
+
+The green component.
+
+**b**
+
+The blue component.
+
+## Properties
+
+### .b : number
+
+The blue component.
+
+Default is `1`.
+
+### .g : number
+
+The green component.
+
+Default is `1`.
+
+### .isColor : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .r : number
+
+The red component.
+
+Default is `1`.
+
+### .NAMES : Object
+
+A dictionary with X11 color names.
+
+Note that multiple words such as Dark Orange become the string 'darkorange'.
+
+## Methods
+
+### .add( color : Color ) : Color
+
+Adds the RGB values of the given color to the RGB values of this color.
+
+**color**
+
+The color to add.
+
+**Returns:** A reference to this color.
+
+### .addColors( color1 : Color, color2 : Color ) : Color
+
+Adds the RGB values of the given colors and stores the result in this instance.
+
+**color1**
+
+The first color.
+
+**color2**
+
+The second color.
+
+**Returns:** A reference to this color.
+
+### .addScalar( s : number ) : Color
+
+Adds the given scalar value to the RGB values of this color.
+
+**s**
+
+The scalar to add.
+
+**Returns:** A reference to this color.
+
+### .applyMatrix3( m : Matrix3 ) : Color
+
+Transforms this color with the given 3x3 matrix.
+
+**m**
+
+The matrix.
+
+**Returns:** A reference to this color.
+
+### .clone() : Color
+
+Returns a new color with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .convertLinearToSRGB() : Color
+
+Converts this color from `LinearSRGBColorSpace` to `SRGBColorSpace`.
+
+**Returns:** A reference to this color.
+
+### .convertSRGBToLinear() : Color
+
+Converts this color from `SRGBColorSpace` to `LinearSRGBColorSpace`.
+
+**Returns:** A reference to this color.
+
+### .copy( color : Color ) : Color
+
+Copies the values of the given color to this instance.
+
+**color**
+
+The color to copy.
+
+**Returns:** A reference to this color.
+
+### .copyLinearToSRGB( color : Color ) : Color
+
+Copies the given color into this color, and then converts this color from `LinearSRGBColorSpace` to `SRGBColorSpace`.
+
+**color**
+
+The color to copy/convert.
+
+**Returns:** A reference to this color.
+
+### .copySRGBToLinear( color : Color ) : Color
+
+Copies the given color into this color, and then converts this color from `SRGBColorSpace` to `LinearSRGBColorSpace`.
+
+**color**
+
+The color to copy/convert.
+
+**Returns:** A reference to this color.
+
+### .equals( c : Color ) : boolean
+
+Returns `true` if this color is equal with the given one.
+
+**c**
+
+The color to test for equality.
+
+**Returns:** Whether this bounding color is equal with the given one.
+
+### .fromArray( array : Array., offset : number ) : Color
+
+Sets this color's RGB components from the given array.
+
+**array**
+
+An array holding the RGB values.
+
+**offset**
+
+The offset into the array.
+
+Default is `0`.
+
+**Returns:** A reference to this color.
+
+### .fromBufferAttribute( attribute : BufferAttribute, index : number ) : Color
+
+Sets the components of this color from the given buffer attribute.
+
+**attribute**
+
+The buffer attribute holding color data.
+
+**index**
+
+The index into the attribute.
+
+**Returns:** A reference to this color.
+
+### .getHSL( target : Object, colorSpace : string ) : Object
+
+Converts the colors RGB values into the HSL format and stores them into the given target object.
+
+**target**
+
+The target object that is used to store the method's result.
+
+**colorSpace**
+
+The color space.
+
+Default is `ColorManagement.workingColorSpace`.
+
+**Returns:** The HSL representation of this color.
+
+### .getHex( colorSpace : string ) : number
+
+Returns the hexadecimal value of this color.
+
+**colorSpace**
+
+The color space.
+
+Default is `SRGBColorSpace`.
+
+**Returns:** The hexadecimal value.
+
+### .getHexString( colorSpace : string ) : string
+
+Returns the hexadecimal value of this color as a string (for example, 'FFFFFF').
+
+**colorSpace**
+
+The color space.
+
+Default is `SRGBColorSpace`.
+
+**Returns:** The hexadecimal value as a string.
+
+### .getRGB( target : Color, colorSpace : string ) : Color
+
+Returns the RGB values of this color and stores them into the given target object.
+
+**target**
+
+The target color that is used to store the method's result.
+
+**colorSpace**
+
+The color space.
+
+Default is `ColorManagement.workingColorSpace`.
+
+**Returns:** The RGB representation of this color.
+
+### .getStyle( colorSpace : string ) : string
+
+Returns the value of this color as a CSS style string. Example: `rgb(255,0,0)`.
+
+**colorSpace**
+
+The color space.
+
+Default is `SRGBColorSpace`.
+
+**Returns:** The CSS representation of this color.
+
+### .lerp( color : Color, alpha : number ) : Color
+
+Linearly interpolates this color's RGB values toward the RGB values of the given color. The alpha argument can be thought of as the ratio between the two colors, where `0.0` is this color and `1.0` is the first argument.
+
+**color**
+
+The color to converge on.
+
+**alpha**
+
+The interpolation factor in the closed interval `[0,1]`.
+
+**Returns:** A reference to this color.
+
+### .lerpColors( color1 : Color, color2 : Color, alpha : number ) : Color
+
+Linearly interpolates between the given colors and stores the result in this instance. The alpha argument can be thought of as the ratio between the two colors, where `0.0` is the first and `1.0` is the second color.
+
+**color1**
+
+The first color.
+
+**color2**
+
+The second color.
+
+**alpha**
+
+The interpolation factor in the closed interval `[0,1]`.
+
+**Returns:** A reference to this color.
+
+### .lerpHSL( color : Color, alpha : number ) : Color
+
+Linearly interpolates this color's HSL values toward the HSL values of the given color. It differs from [Color#lerp](Color.html#lerp) by not interpolating straight from one color to the other, but instead going through all the hues in between those two colors. The alpha argument can be thought of as the ratio between the two colors, where 0.0 is this color and 1.0 is the first argument.
+
+**color**
+
+The color to converge on.
+
+**alpha**
+
+The interpolation factor in the closed interval `[0,1]`.
+
+**Returns:** A reference to this color.
+
+### .multiply( color : Color ) : Color
+
+Multiplies the RGB values of the given color with the RGB values of this color.
+
+**color**
+
+The color to multiply.
+
+**Returns:** A reference to this color.
+
+### .multiplyScalar( s : number ) : Color
+
+Multiplies the given scalar value with the RGB values of this color.
+
+**s**
+
+The scalar to multiply.
+
+**Returns:** A reference to this color.
+
+### .offsetHSL( h : number, s : number, l : number ) : Color
+
+Adds the given HSL values to this color's values. Internally, this converts the color's RGB values to HSL, adds HSL and then converts the color back to RGB.
+
+**h**
+
+Hue value between `0.0` and `1.0`.
+
+**s**
+
+Saturation value between `0.0` and `1.0`.
+
+**l**
+
+Lightness value between `0.0` and `1.0`.
+
+**Returns:** A reference to this color.
+
+### .set( r : number | string | Color, g : number, b : number ) : Color
+
+Sets the colors's components from the given values.
+
+**r**
+
+The red component of the color. If `g` and `b` are not provided, it can be hexadecimal triplet, a CSS-style string or another `Color` instance.
+
+**g**
+
+The green component.
+
+**b**
+
+The blue component.
+
+**Returns:** A reference to this color.
+
+### .setColorName( style : string, colorSpace : string ) : Color
+
+Sets this color from a color name. Faster than [Color#setStyle](Color.html#setStyle) if you don't need the other CSS-style formats.
+
+For convenience, the list of names is exposed in `Color.NAMES` as a hash.
+
+```js
+Color.NAMES.aliceblue // returns 0xF0F8FF
+```
+
+**style**
+
+The color name.
+
+**colorSpace**
+
+The color space.
+
+Default is `SRGBColorSpace`.
+
+**Returns:** A reference to this color.
+
+### .setFromVector3( v : Vector3 ) : Color
+
+Sets the color's RGB components from the given 3D vector.
+
+**v**
+
+The vector to set.
+
+**Returns:** A reference to this color.
+
+### .setHSL( h : number, s : number, l : number, colorSpace : string ) : Color
+
+Sets this color from RGB values.
+
+**h**
+
+Hue value between `0.0` and `1.0`.
+
+**s**
+
+Saturation value between `0.0` and `1.0`.
+
+**l**
+
+Lightness value between `0.0` and `1.0`.
+
+**colorSpace**
+
+The color space.
+
+Default is `ColorManagement.workingColorSpace`.
+
+**Returns:** A reference to this color.
+
+### .setHex( hex : number, colorSpace : string ) : Color
+
+Sets this color from a hexadecimal value.
+
+**hex**
+
+The hexadecimal value.
+
+**colorSpace**
+
+The color space.
+
+Default is `SRGBColorSpace`.
+
+**Returns:** A reference to this color.
+
+### .setRGB( r : number, g : number, b : number, colorSpace : string ) : Color
+
+Sets this color from RGB values.
+
+**r**
+
+Red channel value between `0.0` and `1.0`.
+
+**g**
+
+Green channel value between `0.0` and `1.0`.
+
+**b**
+
+Blue channel value between `0.0` and `1.0`.
+
+**colorSpace**
+
+The color space.
+
+Default is `ColorManagement.workingColorSpace`.
+
+**Returns:** A reference to this color.
+
+### .setScalar( scalar : number ) : Color
+
+Sets the colors's components to the given scalar value.
+
+**scalar**
+
+The scalar value.
+
+**Returns:** A reference to this color.
+
+### .setStyle( style : string, colorSpace : string ) : Color
+
+Sets this color from a CSS-style string. For example, `rgb(250, 0,0)`, `rgb(100%, 0%, 0%)`, `hsl(0, 100%, 50%)`, `#ff0000`, `#f00`, or `red` ( or any [X11 color name](https://en.wikipedia.org/wiki/X11_color_names#Color_name_chart) - all 140 color names are supported).
+
+**style**
+
+Color as a CSS-style string.
+
+**colorSpace**
+
+The color space.
+
+Default is `SRGBColorSpace`.
+
+**Returns:** A reference to this color.
+
+### .sub( color : Color ) : Color
+
+Subtracts the RGB values of the given color from the RGB values of this color.
+
+**color**
+
+The color to subtract.
+
+**Returns:** A reference to this color.
+
+### .toArray( array : Array., offset : number ) : Array.
+
+Writes the RGB components of this color to the given array. If no array is provided, the method returns a new instance.
+
+**array**
+
+The target array holding the color components.
+
+Default is `[]`.
+
+**offset**
+
+Index of the first element in the array.
+
+Default is `0`.
+
+**Returns:** The color components.
+
+### .toJSON() : number
+
+This methods defines the serialization result of this class. Returns the color as a hexadecimal value.
+
+**Returns:** The hexadecimal value.
+
+## Source
+
+[src/math/Color.js](https://github.com/mrdoob/three.js/blob/master/src/math/Color.js)
\ No newline at end of file
diff --git a/docs/pages/ColorConverter.html.md b/docs/pages/ColorConverter.html.md
new file mode 100644
index 00000000000000..a54d5fc364cdf8
--- /dev/null
+++ b/docs/pages/ColorConverter.html.md
@@ -0,0 +1,53 @@
+# ColorConverter
+
+A utility class with helper functions for color conversion.
+
+## Import
+
+ColorConverter is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { ColorConverter } from 'three/addons/math/ColorConverter.js';
+```
+
+## Static Methods
+
+### .getHSV( color : Color, target : Object ) : Object
+
+Returns a HSV color representation of the given color object.
+
+**color**
+
+The color to get HSV values from.
+
+**target**
+
+The target object that is used to store the method's result.
+
+**Returns:** The HSV color.
+
+### .setHSV( color : Color, h : number, s : number, v : number ) : Color
+
+Sets the given HSV color definition to the given color object.
+
+**color**
+
+The color to set.
+
+**h**
+
+The hue.
+
+**s**
+
+The saturation.
+
+**v**
+
+The value.
+
+**Returns:** The update color.
+
+## Source
+
+[examples/jsm/math/ColorConverter.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/math/ColorConverter.js)
\ No newline at end of file
diff --git a/docs/pages/ColorKeyframeTrack.html.md b/docs/pages/ColorKeyframeTrack.html.md
new file mode 100644
index 00000000000000..17c2816796e4df
--- /dev/null
+++ b/docs/pages/ColorKeyframeTrack.html.md
@@ -0,0 +1,41 @@
+*Inheritance: KeyframeTrack →*
+
+# ColorKeyframeTrack
+
+A track for color keyframe values.
+
+## Constructor
+
+### new ColorKeyframeTrack( name : string, times : Array., values : Array., interpolation : InterpolateLinear | InterpolateDiscrete | InterpolateSmooth )
+
+Constructs a new color keyframe track.
+
+**name**
+
+The keyframe track's name.
+
+**times**
+
+A list of keyframe times.
+
+**values**
+
+A list of keyframe values.
+
+**interpolation**
+
+The interpolation type.
+
+## Properties
+
+### .ValueTypeName : string
+
+The value type name.
+
+Default is `'color'`.
+
+**Overrides:** [KeyframeTrack#ValueTypeName](KeyframeTrack.html#ValueTypeName)
+
+## Source
+
+[src/animation/tracks/ColorKeyframeTrack.js](https://github.com/mrdoob/three.js/blob/master/src/animation/tracks/ColorKeyframeTrack.js)
\ No newline at end of file
diff --git a/docs/pages/ColorSpaceNode.html.md b/docs/pages/ColorSpaceNode.html.md
new file mode 100644
index 00000000000000..5690a9f7a4e6a7
--- /dev/null
+++ b/docs/pages/ColorSpaceNode.html.md
@@ -0,0 +1,57 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# ColorSpaceNode
+
+This node represents a color space conversion. Meaning it converts a color value from a source to a target color space.
+
+## Constructor
+
+### new ColorSpaceNode( colorNode : Node, source : string, target : string )
+
+Constructs a new color space node.
+
+**colorNode**
+
+Represents the color to convert.
+
+**source**
+
+The source color space.
+
+**target**
+
+The target color space.
+
+## Properties
+
+### .colorNode : Node
+
+Represents the color to convert.
+
+### .source : string
+
+The source color space.
+
+### .target : string
+
+The target color space.
+
+## Methods
+
+### .resolveColorSpace( builder : NodeBuilder, colorSpace : string ) : string
+
+This method resolves the constants `WORKING_COLOR_SPACE` and `OUTPUT_COLOR_SPACE` based on the current configuration of the color management and renderer.
+
+**builder**
+
+The current node builder.
+
+**colorSpace**
+
+The color space to resolve.
+
+**Returns:** The resolved color space.
+
+## Source
+
+[src/nodes/display/ColorSpaceNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/display/ColorSpaceNode.js)
\ No newline at end of file
diff --git a/docs/pages/CompressedArrayTexture.html.md b/docs/pages/CompressedArrayTexture.html.md
new file mode 100644
index 00000000000000..6ca0431ef99a2b
--- /dev/null
+++ b/docs/pages/CompressedArrayTexture.html.md
@@ -0,0 +1,83 @@
+*Inheritance: EventDispatcher → Texture → CompressedTexture →*
+
+# CompressedArrayTexture
+
+Creates a texture 2D array based on data in compressed form.
+
+These texture are usually loaded with [CompressedTextureLoader](CompressedTextureLoader.html).
+
+## Constructor
+
+### new CompressedArrayTexture( mipmaps : Array., width : number, height : number, depth : number, format : number, type : number )
+
+Constructs a new compressed array texture.
+
+**mipmaps**
+
+This array holds for all mipmaps (including the bases mip) the data and dimensions.
+
+**width**
+
+The width of the texture.
+
+**height**
+
+The height of the texture.
+
+**depth**
+
+The depth of the texture.
+
+**format**
+
+The min filter value.
+
+Default is `RGBAFormat`.
+
+**type**
+
+The min filter value.
+
+Default is `UnsignedByteType`.
+
+## Properties
+
+### .image : Object
+
+The image property of a compressed texture just defines its dimensions.
+
+**Overrides:** [CompressedTexture#image](CompressedTexture.html#image)
+
+### .isCompressedArrayTexture : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .layerUpdates : Set.
+
+A set of all layers which need to be updated in the texture.
+
+### .wrapR : RepeatWrapping | ClampToEdgeWrapping | MirroredRepeatWrapping
+
+This defines how the texture is wrapped in the depth and corresponds to _W_ in UVW mapping.
+
+Default is `ClampToEdgeWrapping`.
+
+## Methods
+
+### .addLayerUpdate( layerIndex : number )
+
+Describes that a specific layer of the texture needs to be updated. Normally when [Texture#needsUpdate](Texture.html#needsUpdate) is set to `true`, the entire compressed texture array is sent to the GPU. Marking specific layers will only transmit subsets of all mipmaps associated with a specific depth in the array which is often much more performant.
+
+**layerIndex**
+
+The layer index that should be updated.
+
+### .clearLayerUpdates()
+
+Resets the layer updates registry.
+
+## Source
+
+[src/textures/CompressedArrayTexture.js](https://github.com/mrdoob/three.js/blob/master/src/textures/CompressedArrayTexture.js)
\ No newline at end of file
diff --git a/docs/pages/CompressedCubeTexture.html.md b/docs/pages/CompressedCubeTexture.html.md
new file mode 100644
index 00000000000000..56487bb1761e96
--- /dev/null
+++ b/docs/pages/CompressedCubeTexture.html.md
@@ -0,0 +1,47 @@
+*Inheritance: EventDispatcher → Texture → CompressedTexture →*
+
+# CompressedCubeTexture
+
+Creates a cube texture based on data in compressed form.
+
+These texture are usually loaded with [CompressedTextureLoader](CompressedTextureLoader.html).
+
+## Constructor
+
+### new CompressedCubeTexture( images : Array., format : number, type : number )
+
+Constructs a new compressed texture.
+
+**images**
+
+An array of compressed textures.
+
+**format**
+
+The texture format.
+
+Default is `RGBAFormat`.
+
+**type**
+
+The texture type.
+
+Default is `UnsignedByteType`.
+
+## Properties
+
+### .isCompressedCubeTexture : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .isCubeTexture : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/textures/CompressedCubeTexture.js](https://github.com/mrdoob/three.js/blob/master/src/textures/CompressedCubeTexture.js)
\ No newline at end of file
diff --git a/docs/pages/CompressedTexture.html.md b/docs/pages/CompressedTexture.html.md
new file mode 100644
index 00000000000000..2be9bf6ba90216
--- /dev/null
+++ b/docs/pages/CompressedTexture.html.md
@@ -0,0 +1,123 @@
+*Inheritance: EventDispatcher → Texture →*
+
+# CompressedTexture
+
+Creates a texture based on data in compressed form.
+
+These texture are usually loaded with [CompressedTextureLoader](CompressedTextureLoader.html).
+
+## Constructor
+
+### new CompressedTexture( mipmaps : Array., width : number, height : number, format : number, type : number, mapping : number, wrapS : number, wrapT : number, magFilter : number, minFilter : number, anisotropy : number, colorSpace : string )
+
+Constructs a new compressed texture.
+
+**mipmaps**
+
+This array holds for all mipmaps (including the bases mip) the data and dimensions.
+
+**width**
+
+The width of the texture.
+
+**height**
+
+The height of the texture.
+
+**format**
+
+The texture format.
+
+Default is `RGBAFormat`.
+
+**type**
+
+The texture type.
+
+Default is `UnsignedByteType`.
+
+**mapping**
+
+The texture mapping.
+
+Default is `Texture.DEFAULT_MAPPING`.
+
+**wrapS**
+
+The wrapS value.
+
+Default is `ClampToEdgeWrapping`.
+
+**wrapT**
+
+The wrapT value.
+
+Default is `ClampToEdgeWrapping`.
+
+**magFilter**
+
+The mag filter value.
+
+Default is `LinearFilter`.
+
+**minFilter**
+
+The min filter value.
+
+Default is `LinearMipmapLinearFilter`.
+
+**anisotropy**
+
+The anisotropy value.
+
+Default is `Texture.DEFAULT_ANISOTROPY`.
+
+**colorSpace**
+
+The color space.
+
+Default is `NoColorSpace`.
+
+## Properties
+
+### .flipY : boolean (readonly)
+
+If set to `true`, the texture is flipped along the vertical axis when uploaded to the GPU.
+
+Overwritten and set to `false` by default since it is not possible to flip compressed textures.
+
+Default is `false`.
+
+**Overrides:** [Texture#flipY](Texture.html#flipY)
+
+### .generateMipmaps : boolean (readonly)
+
+Whether to generate mipmaps (if possible) for a texture.
+
+Overwritten and set to `false` by default since it is not possible to generate mipmaps for compressed data. Mipmaps must be embedded in the compressed texture file.
+
+Default is `false`.
+
+**Overrides:** [Texture#generateMipmaps](Texture.html#generateMipmaps)
+
+### .image : Object
+
+The image property of a compressed texture just defines its dimensions.
+
+**Overrides:** [Texture#image](Texture.html#image)
+
+### .isCompressedTexture : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .mipmaps : Array.
+
+This array holds for all mipmaps (including the bases mip) the data and dimensions.
+
+**Overrides:** [Texture#mipmaps](Texture.html#mipmaps)
+
+## Source
+
+[src/textures/CompressedTexture.js](https://github.com/mrdoob/three.js/blob/master/src/textures/CompressedTexture.js)
\ No newline at end of file
diff --git a/docs/pages/CompressedTextureLoader.html.md b/docs/pages/CompressedTextureLoader.html.md
new file mode 100644
index 00000000000000..3023d2657a735f
--- /dev/null
+++ b/docs/pages/CompressedTextureLoader.html.md
@@ -0,0 +1,83 @@
+*Inheritance: Loader →*
+
+# CompressedTextureLoader
+
+Abstract base class for loading compressed texture formats S3TC, ASTC or ETC. Textures are internally loaded via [FileLoader](FileLoader.html).
+
+Derived classes have to implement the `parse()` method which holds the parsing for the respective format.
+
+## Constructor
+
+### new CompressedTextureLoader( manager : LoadingManager ) (abstract)
+
+Constructs a new compressed texture loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback ) : CompressedTexture
+
+Starts loading from the given URL and passes the loaded compressed texture to the `onLoad()` callback. The method also returns a new texture object which can directly be used for material creation. If you do it this way, the texture may pop up in your scene once the respective loading process is finished.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+**Returns:** The compressed texture.
+
+## Type Definitions
+
+### .TexData
+
+Represents the result object type of the `parse()` method.
+
+**width**
+number
+
+The width of the base mip.
+
+**height**
+number
+
+The width of the base mip.
+
+**isCubemap**
+boolean
+
+Whether the data represent a cubemap or not.
+
+**mipmapCount**
+number
+
+The mipmap count.
+
+**mipmaps**
+Array.<{data:TypedArray, width:number, height:number}>
+
+An array holding the mipmaps. Each entry holds the data and the dimensions for each level.
+
+**format**
+number
+
+The texture format.
+
+## Source
+
+[src/loaders/CompressedTextureLoader.js](https://github.com/mrdoob/three.js/blob/master/src/loaders/CompressedTextureLoader.js)
\ No newline at end of file
diff --git a/docs/pages/ComputeBuiltinNode.html.md b/docs/pages/ComputeBuiltinNode.html.md
new file mode 100644
index 00000000000000..8b7a743a9a2367
--- /dev/null
+++ b/docs/pages/ComputeBuiltinNode.html.md
@@ -0,0 +1,81 @@
+*Inheritance: EventDispatcher → Node →*
+
+# ComputeBuiltinNode
+
+`ComputeBuiltinNode` represents a compute-scope builtin value that expose information about the currently running dispatch and/or the device it is running on.
+
+This node can only be used with a WebGPU backend.
+
+## Constructor
+
+### new ComputeBuiltinNode( builtinName : string, nodeType : string )
+
+Constructs a new compute builtin node.
+
+**builtinName**
+
+The built-in name.
+
+**nodeType**
+
+The node type.
+
+## Methods
+
+### .getBuiltinName( builder : NodeBuilder ) : string
+
+Returns the builtin name.
+
+**builder**
+
+The current node builder.
+
+**Returns:** The builtin name.
+
+### .getHash( builder : NodeBuilder ) : string
+
+This method is overwritten since hash is derived from the built-in name.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [Node#getHash](Node.html#getHash)
+
+**Returns:** The hash.
+
+### .getNodeType( builder : NodeBuilder ) : string
+
+This method is overwritten since the node type is simply derived from `nodeType`..
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [Node#getNodeType](Node.html#getNodeType)
+
+**Returns:** The node type.
+
+### .hasBuiltin( builder : NodeBuilder ) : boolean
+
+Whether the current node builder has the builtin or not.
+
+**builder**
+
+The current node builder.
+
+**Returns:** Whether the builder has the builtin or not.
+
+### .setBuiltinName( builtinName : string ) : ComputeBuiltinNode
+
+Sets the builtin name.
+
+**builtinName**
+
+The built-in name.
+
+**Returns:** A reference to this node.
+
+## Source
+
+[src/nodes/gpgpu/ComputeBuiltinNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/gpgpu/ComputeBuiltinNode.js)
\ No newline at end of file
diff --git a/docs/pages/ComputeNode.html.md b/docs/pages/ComputeNode.html.md
new file mode 100644
index 00000000000000..0773c6e2e8da35
--- /dev/null
+++ b/docs/pages/ComputeNode.html.md
@@ -0,0 +1,133 @@
+*Inheritance: EventDispatcher → Node →*
+
+# ComputeNode
+
+TODO
+
+## Constructor
+
+### new ComputeNode( computeNode : Node, workgroupSize : Array. )
+
+Constructs a new compute node.
+
+**computeNode**
+
+TODO
+
+**workgroupSize**
+
+TODO.
+
+## Properties
+
+### .computeNode : Node
+
+TODO
+
+### .count : number | Array.
+
+TODO
+
+### .isComputeNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .name : string
+
+The name or label of the uniform.
+
+Default is `''`.
+
+**Overrides:** [Node#name](Node.html#name)
+
+### .onInitFunction : function
+
+TODO
+
+### .updateBeforeType : string
+
+The `updateBeforeType` is set to `NodeUpdateType.OBJECT` since [ComputeNode#updateBefore](ComputeNode.html#updateBefore) is executed once per object by default.
+
+Default is `'object'`.
+
+**Overrides:** [Node#updateBeforeType](Node.html#updateBeforeType)
+
+### .version : number
+
+TODO
+
+**Overrides:** [Node#version](Node.html#version)
+
+### .workgroupSize : Array.
+
+TODO
+
+Default is `[ 64 ]`.
+
+## Methods
+
+### .dispose()
+
+Executes the `dispose` event for this node.
+
+**Overrides:** [Node#dispose](Node.html#dispose)
+
+### .getCount() : number | Array.
+
+TODO
+
+### .label( name : string ) : ComputeNode
+
+Sets the [ComputeNode#name](ComputeNode.html#name) property.
+
+**name**
+
+The name of the uniform.
+
+**Deprecated:** Yes
+
+**Returns:** A reference to this node.
+
+### .onInit( callback : function ) : ComputeNode
+
+TODO
+
+**callback**
+
+TODO.
+
+**Returns:** A reference to this node.
+
+### .setCount( count : number | Array. ) : ComputeNode
+
+TODO
+
+**count**
+
+Array with \[ x, y, z \] values for dispatch or a single number for the count
+
+### .setName( name : string ) : ComputeNode
+
+Sets the [ComputeNode#name](ComputeNode.html#name) property.
+
+**name**
+
+The name of the uniform.
+
+**Returns:** A reference to this node.
+
+### .updateBefore( frame : NodeFrame )
+
+The method execute the compute for this node.
+
+**frame**
+
+A reference to the current node frame.
+
+**Overrides:** [Node#updateBefore](Node.html#updateBefore)
+
+## Source
+
+[src/nodes/gpgpu/ComputeNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/gpgpu/ComputeNode.js)
\ No newline at end of file
diff --git a/docs/pages/ConditionalNode.html.md b/docs/pages/ConditionalNode.html.md
new file mode 100644
index 00000000000000..6d6ad1e5ffd879
--- /dev/null
+++ b/docs/pages/ConditionalNode.html.md
@@ -0,0 +1,69 @@
+*Inheritance: EventDispatcher → Node →*
+
+# ConditionalNode
+
+Represents a logical `if/else` statement. Can be used as an alternative to the `If()`/`Else()` syntax.
+
+The corresponding TSL `select()` looks like so:
+
+The `select()` method is called in a chaining fashion on a condition. The parameter nodes of `select()` determine the outcome of the entire statement.
+
+## Code Example
+
+```js
+velocity = position.greaterThanEqual( limit ).select( velocity.negate(), velocity );
+```
+
+## Constructor
+
+### new ConditionalNode( condNode : Node, ifNode : Node, elseNode : Node )
+
+Constructs a new conditional node.
+
+**condNode**
+
+The node that defines the condition.
+
+**ifNode**
+
+The node that is evaluate when the condition ends up `true`.
+
+**elseNode**
+
+The node that is evaluate when the condition ends up `false`.
+
+Default is `null`.
+
+## Properties
+
+### .condNode : Node
+
+The node that defines the condition.
+
+### .elseNode : Node
+
+The node that is evaluate when the condition ends up `false`.
+
+Default is `null`.
+
+### .ifNode : Node
+
+The node that is evaluate when the condition ends up `true`.
+
+## Methods
+
+### .getNodeType( builder : NodeBuilder ) : string
+
+This method is overwritten since the node type is inferred from the if/else nodes.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [Node#getNodeType](Node.html#getNodeType)
+
+**Returns:** The node type.
+
+## Source
+
+[src/nodes/math/ConditionalNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/math/ConditionalNode.js)
\ No newline at end of file
diff --git a/docs/pages/ConeGeometry.html.md b/docs/pages/ConeGeometry.html.md
new file mode 100644
index 00000000000000..cdafdc391a0117
--- /dev/null
+++ b/docs/pages/ConeGeometry.html.md
@@ -0,0 +1,86 @@
+*Inheritance: EventDispatcher → BufferGeometry → CylinderGeometry →*
+
+# ConeGeometry
+
+A geometry class for representing a cone.
+
+## Code Example
+
+```js
+const geometry = new THREE.ConeGeometry( 5, 20, 32 );
+const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
+const cone = new THREE.Mesh(geometry, material );
+scene.add( cone );
+```
+
+## Constructor
+
+### new ConeGeometry( radius : number, height : number, radialSegments : number, heightSegments : number, openEnded : boolean, thetaStart : number, thetaLength : number )
+
+Constructs a new cone geometry.
+
+**radius**
+
+Radius of the cone base.
+
+Default is `1`.
+
+**height**
+
+Height of the cone.
+
+Default is `1`.
+
+**radialSegments**
+
+Number of segmented faces around the circumference of the cone.
+
+Default is `32`.
+
+**heightSegments**
+
+Number of rows of faces along the height of the cone.
+
+Default is `1`.
+
+**openEnded**
+
+Whether the base of the cone is open or capped.
+
+Default is `false`.
+
+**thetaStart**
+
+Start angle for first segment, in radians.
+
+Default is `0`.
+
+**thetaLength**
+
+The central angle, often called theta, of the circular sector, in radians. The default value results in a complete cone.
+
+Default is `Math.PI*2`.
+
+## Properties
+
+### .parameters : Object
+
+Holds the constructor parameters that have been used to generate the geometry. Any modification after instantiation does not change the geometry.
+
+**Overrides:** [CylinderGeometry#parameters](CylinderGeometry.html#parameters)
+
+## Static Methods
+
+### .fromJSON( data : Object ) : ConeGeometry
+
+Factory method for creating an instance of this class from the given JSON object.
+
+**data**
+
+A JSON object representing the serialized geometry.
+
+**Returns:** A new instance.
+
+## Source
+
+[src/geometries/ConeGeometry.js](https://github.com/mrdoob/three.js/blob/master/src/geometries/ConeGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/ConstNode.html.md b/docs/pages/ConstNode.html.md
new file mode 100644
index 00000000000000..83c1001999f162
--- /dev/null
+++ b/docs/pages/ConstNode.html.md
@@ -0,0 +1,45 @@
+*Inheritance: EventDispatcher → Node → InputNode →*
+
+# ConstNode
+
+Class for representing a constant value in the shader.
+
+## Constructor
+
+### new ConstNode( value : any, nodeType : string )
+
+Constructs a new input node.
+
+**value**
+
+The value of this node. Usually a JS primitive or three.js object (vector, matrix, color).
+
+**nodeType**
+
+The node type. If no explicit type is defined, the node tries to derive the type from its value.
+
+Default is `null`.
+
+## Properties
+
+### .isConstNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Methods
+
+### .generateConst( builder : NodeBuilder ) : string
+
+Generates the shader string of the value with the current node builder.
+
+**builder**
+
+The current node builder.
+
+**Returns:** The generated value as a shader string.
+
+## Source
+
+[src/nodes/core/ConstNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/core/ConstNode.js)
\ No newline at end of file
diff --git a/docs/pages/ContextNode.html.md b/docs/pages/ContextNode.html.md
new file mode 100644
index 00000000000000..b95ac27e66b85b
--- /dev/null
+++ b/docs/pages/ContextNode.html.md
@@ -0,0 +1,101 @@
+*Inheritance: EventDispatcher → Node →*
+
+# ContextNode
+
+This node can be used as a context management component for another node. [NodeBuilder](NodeBuilder.html) performs its node building process in a specific context and this node allows the modify the context. A typical use case is to overwrite `getUV()` e.g.:
+
+## Code Example
+
+```js
+node.context( { getUV: () => customCoord } );
+\// or
+material.contextNode = context( { getUV: () => customCoord } );
+\// or
+renderer.contextNode = context( { getUV: () => customCoord } );
+\// or
+scenePass.contextNode = context( { getUV: () => customCoord } );
+```
+
+## Constructor
+
+### new ContextNode( node : Node, value : Object )
+
+Constructs a new context node.
+
+**node**
+
+The node whose context should be modified.
+
+Default is `null`.
+
+**value**
+
+The modified context data.
+
+Default is `{}`.
+
+## Properties
+
+### .isContextNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .node : Node
+
+The node whose context should be modified.
+
+### .value : Object
+
+The modified context data.
+
+Default is `{}`.
+
+## Methods
+
+### .getFlowContextData() : Object
+
+Gathers the context data from all parent context nodes.
+
+**Returns:** The gathered context data.
+
+### .getMemberType( builder : NodeBuilder, name : string ) : string
+
+This method is overwritten to ensure it returns the member type of [ContextNode#node](ContextNode.html#node).
+
+**builder**
+
+The current node builder.
+
+**name**
+
+The member name.
+
+**Overrides:** [Node#getMemberType](Node.html#getMemberType)
+
+**Returns:** The member type.
+
+### .getNodeType( builder : NodeBuilder ) : string
+
+This method is overwritten to ensure it returns the type of [ContextNode#node](ContextNode.html#node).
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [Node#getNodeType](Node.html#getNodeType)
+
+**Returns:** The node type.
+
+### .getScope() : Node
+
+This method is overwritten to ensure it returns the reference to [ContextNode#node](ContextNode.html#node).
+
+**Overrides:** [Node#getScope](Node.html#getScope)
+
+**Returns:** A reference to [ContextNode#node](ContextNode.html#node).
+
+## Source
+
+[src/nodes/core/ContextNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/core/ContextNode.js)
\ No newline at end of file
diff --git a/docs/pages/Controls.html.md b/docs/pages/Controls.html.md
new file mode 100644
index 00000000000000..66371c2a260194
--- /dev/null
+++ b/docs/pages/Controls.html.md
@@ -0,0 +1,87 @@
+*Inheritance: EventDispatcher →*
+
+# Controls
+
+Abstract base class for controls.
+
+## Constructor
+
+### new Controls( object : Object3D, domElement : HTMLElement ) (abstract)
+
+Constructs a new controls instance.
+
+**object**
+
+The object that is managed by the controls.
+
+**domElement**
+
+The HTML element used for event listeners.
+
+Default is `null`.
+
+## Properties
+
+### .domElement : HTMLElement
+
+The HTML element used for event listeners.
+
+Default is `null`.
+
+### .enabled : boolean
+
+Whether the controls responds to user input or not.
+
+Default is `true`.
+
+### .keys : Object
+
+This object defines the keyboard input of the controls.
+
+### .mouseButtons : Object
+
+This object defines what type of actions are assigned to the available mouse buttons. It depends on the control implementation what kind of mouse buttons and actions are supported.
+
+### .object : Object3D
+
+The object that is managed by the controls.
+
+### .state : number
+
+The internal state of the controls.
+
+Default is `-1`.
+
+### .touches : Object
+
+This object defines what type of actions are assigned to what kind of touch interaction. It depends on the control implementation what kind of touch interaction and actions are supported.
+
+## Methods
+
+### .connect( element : HTMLElement )
+
+Connects the controls to the DOM. This method has so called "side effects" since it adds the module's event listeners to the DOM.
+
+**element**
+
+The DOM element to connect to.
+
+### .disconnect()
+
+Disconnects the controls from the DOM.
+
+### .dispose()
+
+Call this method if you no longer want use to the controls. It frees all internal resources and removes all event listeners.
+
+### .update( delta : number )
+
+Controls should implement this method if they have to update their internal state per simulation step.
+
+**delta**
+
+The time delta in seconds.
+
+## Source
+
+[src/extras/Controls.js](https://github.com/mrdoob/three.js/blob/master/src/extras/Controls.js)
\ No newline at end of file
diff --git a/docs/pages/ConvertNode.html.md b/docs/pages/ConvertNode.html.md
new file mode 100644
index 00000000000000..ba10d6c2fc2c39
--- /dev/null
+++ b/docs/pages/ConvertNode.html.md
@@ -0,0 +1,47 @@
+*Inheritance: EventDispatcher → Node →*
+
+# ConvertNode
+
+This module is part of the TSL core and usually not used in app level code. It represents a convert operation during the shader generation process meaning it converts the data type of a node to a target data type.
+
+## Constructor
+
+### new ConvertNode( node : Node, convertTo : string )
+
+Constructs a new convert node.
+
+**node**
+
+The node which type should be converted.
+
+**convertTo**
+
+The target node type. Multiple types can be defined by separating them with a `|` sign.
+
+## Properties
+
+### .convertTo : string
+
+The target node type. Multiple types can be defined by separating them with a `|` sign.
+
+### .node : Node
+
+The node which type should be converted.
+
+## Methods
+
+### .getNodeType( builder : NodeBuilder ) : string
+
+This method is overwritten since the implementation tries to infer the best matching type from the [ConvertNode#convertTo](ConvertNode.html#convertTo) property.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [Node#getNodeType](Node.html#getNodeType)
+
+**Returns:** The node type.
+
+## Source
+
+[src/nodes/utils/ConvertNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/utils/ConvertNode.js)
\ No newline at end of file
diff --git a/docs/pages/ConvexGeometry.html.md b/docs/pages/ConvexGeometry.html.md
new file mode 100644
index 00000000000000..9ca48846e2f062
--- /dev/null
+++ b/docs/pages/ConvexGeometry.html.md
@@ -0,0 +1,36 @@
+*Inheritance: EventDispatcher → BufferGeometry →*
+
+# ConvexGeometry
+
+This class can be used to generate a convex hull for a given array of 3D points. The average time complexity for this task is considered to be O(nlog(n)).
+
+## Code Example
+
+```js
+const geometry = new ConvexGeometry( points );
+const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
+const mesh = new THREE.Mesh( geometry, material );
+scene.add( mesh );
+```
+
+## Import
+
+ConvexGeometry is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { ConvexGeometry } from 'three/addons/geometries/ConvexGeometry.js';
+```
+
+## Constructor
+
+### new ConvexGeometry( points : Array. )
+
+Constructs a new convex geometry.
+
+**points**
+
+An array of points in 3D space which should be enclosed by the convex hull.
+
+## Source
+
+[examples/jsm/geometries/ConvexGeometry.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/geometries/ConvexGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/ConvexHull.html.md b/docs/pages/ConvexHull.html.md
new file mode 100644
index 00000000000000..1b29988e7ce91a
--- /dev/null
+++ b/docs/pages/ConvexHull.html.md
@@ -0,0 +1,85 @@
+# ConvexHull
+
+Can be used to compute the convex hull in 3D space for a given set of points. It is primarily intended for [ConvexGeometry](ConvexGeometry.html).
+
+This Quickhull 3D implementation is a port of [quickhull3d](https://github.com/maurizzzio/quickhull3d/) by Mauricio Poppe.
+
+## Import
+
+ConvexHull is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { ConvexHull } from 'three/addons/math/ConvexHull.js';
+```
+
+## Constructor
+
+### new ConvexHull()
+
+Constructs a new convex hull.
+
+## Methods
+
+### .containsPoint( point : Vector3 ) : boolean
+
+Returns `true` if the given point lies in the convex hull.
+
+**point**
+
+The point to test.
+
+**Returns:** Whether the given point lies in the convex hull or not.
+
+### .intersectRay( ray : Ray, target : Vector3 ) : Vector3
+
+Computes the intersections point of the given ray and this convex hull.
+
+**ray**
+
+The ray to test.
+
+**target**
+
+The target vector that is used to store the method's result.
+
+**Returns:** The intersection point. Returns `null` if not intersection was detected.
+
+### .intersectsRay( ray : Ray ) : boolean
+
+Returns `true` if the given ray intersects with this convex hull.
+
+**ray**
+
+The ray to test.
+
+**Returns:** Whether the given ray intersects with this convex hull or not.
+
+### .makeEmpty() : ConvexHull
+
+Makes the convex hull empty.
+
+**Returns:** A reference to this convex hull.
+
+### .setFromObject( object : Object3D ) : ConvexHull
+
+Computes the convex hull of the given 3D object (including its descendants), accounting for the world transforms of both the 3D object and its descendants.
+
+**object**
+
+The 3D object to compute the convex hull for.
+
+**Returns:** A reference to this convex hull.
+
+### .setFromPoints( points : Array. ) : ConvexHull
+
+Computes to convex hull for the given array of points.
+
+**points**
+
+The array of points in 3D space.
+
+**Returns:** A reference to this convex hull.
+
+## Source
+
+[examples/jsm/math/ConvexHull.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/math/ConvexHull.js)
\ No newline at end of file
diff --git a/docs/pages/ConvexObjectBreaker.html.md b/docs/pages/ConvexObjectBreaker.html.md
new file mode 100644
index 00000000000000..2f6d1b73b47cae
--- /dev/null
+++ b/docs/pages/ConvexObjectBreaker.html.md
@@ -0,0 +1,113 @@
+# ConvexObjectBreaker
+
+This class can be used to subdivide a convex Geometry object into pieces.
+
+Use the function prepareBreakableObject to prepare a Mesh object to be broken. Then, call the various functions to subdivide the object (subdivideByImpact, cutByPlane). Sub-objects that are product of subdivision don't need prepareBreakableObject to be called on them.
+
+Requisites for the object:
+
+* Mesh object must have a buffer geometry and a material.
+* Vertex normals must be planar (not smoothed).
+* The geometry must be convex (this is not checked in the library). You can create convex geometries with [ConvexGeometry](ConvexGeometry.html). The [BoxGeometry](BoxGeometry.html), [SphereGeometry](SphereGeometry.html) and other convex primitives can also be used.
+
+Note: This lib adds member variables to object's userData member (see prepareBreakableObject function) Use with caution and read the code when using with other libs.
+
+## Import
+
+ConvexObjectBreaker is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { ConvexObjectBreaker } from 'three/addons/misc/ConvexObjectBreaker.js';
+```
+
+## Constructor
+
+### new ConvexObjectBreaker( minSizeForBreak : number, smallDelta : number )
+
+Constructs a new convex object breaker.
+
+**minSizeForBreak**
+
+Min size a debris can have to break.
+
+Default is `1.4`.
+
+**smallDelta**
+
+Max distance to consider that a point belongs to a plane.
+
+Default is `0.0001`.
+
+## Methods
+
+### .cutByPlane( object : Object3D, plane : Plane, output : Object ) : number
+
+Subdivides the given 3D object into pieces by a plane.
+
+**object**
+
+The 3D object to subdivide.
+
+**plane**
+
+The plane to cut the 3D object.
+
+**output**
+
+An object that stores the pieces.
+
+**Returns:** The number of pieces.
+
+### .prepareBreakableObject( object : Object3D, mass : number, velocity : Vector3, angularVelocity : Vector3, breakable : boolean )
+
+Must be called for all 3D objects that should be breakable.
+
+**object**
+
+The 3D object. It must have a convex geometry.
+
+**mass**
+
+The 3D object's mass in kg. Must be greater than `0`.
+
+**velocity**
+
+The 3D object's velocity.
+
+**angularVelocity**
+
+The 3D object's angular velocity.
+
+**breakable**
+
+Whether the 3D object is breakable or not.
+
+### .subdivideByImpact( object : Object3D, pointOfImpact : Vector3, normal : Vector3, maxRadialIterations : number, maxRandomIterations : number ) : Array.
+
+Subdivides the given 3D object into pieces by an impact (meaning another object hits the given 3D object at a certain surface point).
+
+**object**
+
+The 3D object to subdivide.
+
+**pointOfImpact**
+
+The point of impact.
+
+**normal**
+
+The impact normal.
+
+**maxRadialIterations**
+
+Iterations for radial cuts.
+
+**maxRandomIterations**
+
+Max random iterations for not-radial cuts.
+
+**Returns:** The array of pieces.
+
+## Source
+
+[examples/jsm/misc/ConvexObjectBreaker.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/misc/ConvexObjectBreaker.js)
\ No newline at end of file
diff --git a/docs/pages/CubeCamera.html.md b/docs/pages/CubeCamera.html.md
new file mode 100644
index 00000000000000..7168bd9dad79ce
--- /dev/null
+++ b/docs/pages/CubeCamera.html.md
@@ -0,0 +1,84 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# CubeCamera
+
+A special type of camera that is positioned in 3D space to render its surroundings into a cube render target. The render target can then be used as an environment map for rendering realtime reflections in your scene.
+
+## Code Example
+
+```js
+// Create cube render target
+const cubeRenderTarget = new THREE.WebGLCubeRenderTarget( 256, { generateMipmaps: true, minFilter: THREE.LinearMipmapLinearFilter } );
+// Create cube camera
+const cubeCamera = new THREE.CubeCamera( 1, 100000, cubeRenderTarget );
+scene.add( cubeCamera );
+// Create car
+const chromeMaterial = new THREE.MeshLambertMaterial( { color: 0xffffff, envMap: cubeRenderTarget.texture } );
+const car = new THREE.Mesh( carGeometry, chromeMaterial );
+scene.add( car );
+// Update the render target cube
+car.visible = false;
+cubeCamera.position.copy( car.position );
+cubeCamera.update( renderer, scene );
+// Render the scene
+car.visible = true;
+renderer.render( scene, camera );
+```
+
+## Constructor
+
+### new CubeCamera( near : number, far : number, renderTarget : WebGLCubeRenderTarget )
+
+Constructs a new cube camera.
+
+**near**
+
+The camera's near plane.
+
+**far**
+
+The camera's far plane.
+
+**renderTarget**
+
+The cube render target.
+
+## Properties
+
+### .activeMipmapLevel : number
+
+The current active mipmap level
+
+Default is `0`.
+
+### .coordinateSystem : WebGLCoordinateSystem | WebGPUCoordinateSystem
+
+The current active coordinate system.
+
+Default is `null`.
+
+### .renderTarget : WebGLCubeRenderTarget
+
+A reference to the cube render target.
+
+## Methods
+
+### .update( renderer : Renderer | WebGLRenderer, scene : Scene )
+
+Calling this method will render the given scene with the given renderer into the cube render target of the camera.
+
+**renderer**
+
+The renderer.
+
+**scene**
+
+The scene to render.
+
+### .updateCoordinateSystem()
+
+Must be called when the coordinate system of the cube camera is changed.
+
+## Source
+
+[src/cameras/CubeCamera.js](https://github.com/mrdoob/three.js/blob/master/src/cameras/CubeCamera.js)
\ No newline at end of file
diff --git a/docs/pages/CubeDepthTexture.html.md b/docs/pages/CubeDepthTexture.html.md
new file mode 100644
index 00000000000000..cd8e1ad83a4120
--- /dev/null
+++ b/docs/pages/CubeDepthTexture.html.md
@@ -0,0 +1,85 @@
+*Inheritance: EventDispatcher → Texture → DepthTexture →*
+
+# CubeDepthTexture
+
+This class can be used to automatically save the depth information of a cube rendering into a cube texture with depth format. Used for PointLight shadows.
+
+## Constructor
+
+### new CubeDepthTexture( size : number, type : number, mapping : number, wrapS : number, wrapT : number, magFilter : number, minFilter : number, anisotropy : number, format : number )
+
+Constructs a new cube depth texture.
+
+**size**
+
+The size (width and height) of each cube face.
+
+**type**
+
+The texture type.
+
+Default is `UnsignedIntType`.
+
+**mapping**
+
+The texture mapping.
+
+Default is `CubeReflectionMapping`.
+
+**wrapS**
+
+The wrapS value.
+
+Default is `ClampToEdgeWrapping`.
+
+**wrapT**
+
+The wrapT value.
+
+Default is `ClampToEdgeWrapping`.
+
+**magFilter**
+
+The mag filter value.
+
+Default is `NearestFilter`.
+
+**minFilter**
+
+The min filter value.
+
+Default is `NearestFilter`.
+
+**anisotropy**
+
+The anisotropy value.
+
+Default is `Texture.DEFAULT_ANISOTROPY`.
+
+**format**
+
+The texture format.
+
+Default is `DepthFormat`.
+
+## Properties
+
+### .images : Array.
+
+Alias for [CubeDepthTexture#image](CubeDepthTexture.html#image).
+
+### .isCubeDepthTexture : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .isCubeTexture : boolean (readonly)
+
+Set to true for cube texture handling in WebGLTextures.
+
+Default is `true`.
+
+## Source
+
+[src/textures/CubeDepthTexture.js](https://github.com/mrdoob/three.js/blob/master/src/textures/CubeDepthTexture.js)
\ No newline at end of file
diff --git a/docs/pages/CubeMapNode.html.md b/docs/pages/CubeMapNode.html.md
new file mode 100644
index 00000000000000..a0ddb995781255
--- /dev/null
+++ b/docs/pages/CubeMapNode.html.md
@@ -0,0 +1,33 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# CubeMapNode
+
+This node can be used to automatically convert environment maps in the equirectangular format into the cube map format.
+
+## Constructor
+
+### new CubeMapNode( envNode : Node )
+
+Constructs a new cube map node.
+
+**envNode**
+
+The node representing the environment map.
+
+## Properties
+
+### .envNode : Node
+
+The node representing the environment map.
+
+### .updateBeforeType : string
+
+The `updateBeforeType` is set to `NodeUpdateType.RENDER` since the node updates the texture once per render in its [CubeMapNode#updateBefore](CubeMapNode.html#updateBefore) method.
+
+Default is `'render'`.
+
+**Overrides:** [TempNode#updateBeforeType](TempNode.html#updateBeforeType)
+
+## Source
+
+[src/nodes/utils/CubeMapNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/utils/CubeMapNode.js)
\ No newline at end of file
diff --git a/docs/pages/CubeRenderTarget.html.md b/docs/pages/CubeRenderTarget.html.md
new file mode 100644
index 00000000000000..30f0920411af30
--- /dev/null
+++ b/docs/pages/CubeRenderTarget.html.md
@@ -0,0 +1,51 @@
+*Inheritance: EventDispatcher → RenderTarget → WebGLRenderTarget → WebGLCubeRenderTarget →*
+
+# CubeRenderTarget
+
+This class represents a cube render target. It is a special version of `WebGLCubeRenderTarget` which is compatible with `WebGPURenderer`.
+
+## Constructor
+
+### new CubeRenderTarget( size : number, options : RenderTarget~Options )
+
+Constructs a new cube render target.
+
+**size**
+
+The size of the render target.
+
+Default is `1`.
+
+**options**
+
+The configuration object.
+
+## Properties
+
+### .isCubeRenderTarget : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Methods
+
+### .fromEquirectangularTexture( renderer : Renderer, texture : Texture ) : CubeRenderTarget
+
+Converts the given equirectangular texture to a cube map.
+
+**renderer**
+
+The renderer.
+
+**texture**
+
+The equirectangular texture.
+
+**Overrides:** [WebGLCubeRenderTarget#fromEquirectangularTexture](WebGLCubeRenderTarget.html#fromEquirectangularTexture)
+
+**Returns:** A reference to this cube render target.
+
+## Source
+
+[src/renderers/common/CubeRenderTarget.js](https://github.com/mrdoob/three.js/blob/master/src/renderers/common/CubeRenderTarget.js)
\ No newline at end of file
diff --git a/docs/pages/CubeTexture.html.md b/docs/pages/CubeTexture.html.md
new file mode 100644
index 00000000000000..a2a18baef46e2a
--- /dev/null
+++ b/docs/pages/CubeTexture.html.md
@@ -0,0 +1,108 @@
+*Inheritance: EventDispatcher → Texture →*
+
+# CubeTexture
+
+Creates a cube texture made up of six images.
+
+## Code Example
+
+```js
+const loader = new THREE.CubeTextureLoader();
+loader.setPath( 'textures/cube/pisa/' );
+const textureCube = loader.load( [
+ 'px.png', 'nx.png', 'py.png', 'ny.png', 'pz.png', 'nz.png'
+] );
+const material = new THREE.MeshBasicMaterial( { color: 0xffffff, envMap: textureCube } );
+```
+
+## Constructor
+
+### new CubeTexture( images : Array., mapping : number, wrapS : number, wrapT : number, magFilter : number, minFilter : number, format : number, type : number, anisotropy : number, colorSpace : string )
+
+Constructs a new cube texture.
+
+**images**
+
+An array holding a image for each side of a cube.
+
+Default is `[]`.
+
+**mapping**
+
+The texture mapping.
+
+Default is `CubeReflectionMapping`.
+
+**wrapS**
+
+The wrapS value.
+
+Default is `ClampToEdgeWrapping`.
+
+**wrapT**
+
+The wrapT value.
+
+Default is `ClampToEdgeWrapping`.
+
+**magFilter**
+
+The mag filter value.
+
+Default is `LinearFilter`.
+
+**minFilter**
+
+The min filter value.
+
+Default is `LinearMipmapLinearFilter`.
+
+**format**
+
+The texture format.
+
+Default is `RGBAFormat`.
+
+**type**
+
+The texture type.
+
+Default is `UnsignedByteType`.
+
+**anisotropy**
+
+The anisotropy value.
+
+Default is `Texture.DEFAULT_ANISOTROPY`.
+
+**colorSpace**
+
+The color space value.
+
+Default is `NoColorSpace`.
+
+## Properties
+
+### .flipY : boolean
+
+If set to `true`, the texture is flipped along the vertical axis when uploaded to the GPU.
+
+Overwritten and set to `false` by default.
+
+Default is `false`.
+
+**Overrides:** [Texture#flipY](Texture.html#flipY)
+
+### .images : Array.
+
+Alias for [CubeTexture#image](CubeTexture.html#image).
+
+### .isCubeTexture : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/textures/CubeTexture.js](https://github.com/mrdoob/three.js/blob/master/src/textures/CubeTexture.js)
\ No newline at end of file
diff --git a/docs/pages/CubeTextureLoader.html.md b/docs/pages/CubeTextureLoader.html.md
new file mode 100644
index 00000000000000..879f39c7b5881f
--- /dev/null
+++ b/docs/pages/CubeTextureLoader.html.md
@@ -0,0 +1,61 @@
+*Inheritance: Loader →*
+
+# CubeTextureLoader
+
+Class for loading cube textures. Images are internally loaded via [ImageLoader](ImageLoader.html).
+
+The loader returns an instance of [CubeTexture](CubeTexture.html) and expects the cube map to be defined as six separate images representing the sides of a cube. Other cube map definitions like vertical and horizontal cross, column and row layouts are not supported.
+
+Note that, by convention, cube maps are specified in a coordinate system in which positive-x is to the right when looking up the positive-z axis -- in other words, using a left-handed coordinate system. Since three.js uses a right-handed coordinate system, environment maps used in three.js will have pos-x and neg-x swapped.
+
+The loaded cube texture is in sRGB color space. Meaning [Texture#colorSpace](Texture.html#colorSpace) is set to `SRGBColorSpace` by default.
+
+## Code Example
+
+```js
+const loader = new THREE.CubeTextureLoader().setPath( 'textures/cubeMaps/' );
+const cubeTexture = await loader.loadAsync( [
+ 'px.png', 'nx.png', 'py.png', 'ny.png', 'pz.png', 'nz.png'
+] );
+scene.background = cubeTexture;
+```
+
+## Constructor
+
+### new CubeTextureLoader( manager : LoadingManager )
+
+Constructs a new cube texture loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .load( urls : Array., onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback ) : CubeTexture
+
+Starts loading from the given URL and pass the fully loaded cube texture to the `onLoad()` callback. The method also returns a new cube texture object which can directly be used for material creation. If you do it this way, the cube texture may pop up in your scene once the respective loading process is finished.
+
+**urls**
+
+Array of 6 URLs to images, one for each side of the cube texture. The urls should be specified in the following order: pos-x, neg-x, pos-y, neg-y, pos-z, neg-z. An array of data URIs are allowed as well.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Unsupported in this loader.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+**Returns:** The cube texture.
+
+## Source
+
+[src/loaders/CubeTextureLoader.js](https://github.com/mrdoob/three.js/blob/master/src/loaders/CubeTextureLoader.js)
\ No newline at end of file
diff --git a/docs/pages/CubeTextureNode.html.md b/docs/pages/CubeTextureNode.html.md
new file mode 100644
index 00000000000000..c4bf1594c43fb6
--- /dev/null
+++ b/docs/pages/CubeTextureNode.html.md
@@ -0,0 +1,109 @@
+*Inheritance: EventDispatcher → Node → InputNode → UniformNode → TextureNode →*
+
+# CubeTextureNode
+
+This type of uniform node represents a cube texture.
+
+## Constructor
+
+### new CubeTextureNode( value : CubeTexture, uvNode : Node., levelNode : Node., biasNode : Node. )
+
+Constructs a new cube texture node.
+
+**value**
+
+The cube texture.
+
+**uvNode**
+
+The uv node.
+
+Default is `null`.
+
+**levelNode**
+
+The level node.
+
+Default is `null`.
+
+**biasNode**
+
+The bias node.
+
+Default is `null`.
+
+## Properties
+
+### .isCubeTextureNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Methods
+
+### .generateUV( builder : NodeBuilder, cubeUV : Node ) : string
+
+Generates the uv code snippet.
+
+**builder**
+
+The current node builder.
+
+**cubeUV**
+
+The uv node to generate code for.
+
+**Overrides:** [TextureNode#generateUV](TextureNode.html#generateUV)
+
+**Returns:** The generated code snippet.
+
+### .getDefaultUV() : Node.
+
+Returns a default uvs based on the mapping type of the cube texture.
+
+**Overrides:** [TextureNode#getDefaultUV](TextureNode.html#getDefaultUV)
+
+**Returns:** The default uv attribute.
+
+### .getInputType( builder : NodeBuilder ) : string
+
+Overwrites the default implementation to return the appropriate cube texture type.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TextureNode#getInputType](TextureNode.html#getInputType)
+
+**Returns:** The input type.
+
+### .setUpdateMatrix( value : boolean )
+
+Overwritten with an empty implementation since the `updateMatrix` flag is ignored for cube textures. The uv transformation matrix is not applied to cube textures.
+
+**value**
+
+The update toggle.
+
+**Overrides:** [TextureNode#setUpdateMatrix](TextureNode.html#setUpdateMatrix)
+
+### .setupUV( builder : NodeBuilder, uvNode : Node ) : Node
+
+Setups the uv node. Depending on the backend as well as the texture type, it might be necessary to modify the uv node for correct sampling.
+
+**builder**
+
+The current node builder.
+
+**uvNode**
+
+The uv node to setup.
+
+**Overrides:** [TextureNode#setupUV](TextureNode.html#setupUV)
+
+**Returns:** The updated uv node.
+
+## Source
+
+[src/nodes/accessors/CubeTextureNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/accessors/CubeTextureNode.js)
\ No newline at end of file
diff --git a/docs/pages/CubeTexturePass.html.md b/docs/pages/CubeTexturePass.html.md
new file mode 100644
index 00000000000000..03e19491d8538d
--- /dev/null
+++ b/docs/pages/CubeTexturePass.html.md
@@ -0,0 +1,103 @@
+*Inheritance: Pass →*
+
+# CubeTexturePass
+
+This pass can be used to render a cube texture over the entire screen.
+
+## Code Example
+
+```js
+const cubeMap = new THREE.CubeTextureLoader().load( urls );
+const cubeTexturePass = new CubeTexturePass( camera, cubemap );
+composer.addPass( cubeTexturePass );
+```
+
+## Import
+
+CubeTexturePass is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { CubeTexturePass } from 'three/addons/postprocessing/CubeTexturePass.js';
+```
+
+## Constructor
+
+### new CubeTexturePass( camera : PerspectiveCamera, tCube : CubeTexture, opacity : number )
+
+Constructs a new cube texture pass.
+
+**camera**
+
+The camera.
+
+**tCube**
+
+The cube texture to render.
+
+**opacity**
+
+The opacity.
+
+Default is `1`.
+
+## Properties
+
+### .camera : PerspectiveCamera
+
+The camera.
+
+### .needsSwap : boolean
+
+Overwritten to disable the swap.
+
+Default is `false`.
+
+**Overrides:** [Pass#needsSwap](Pass.html#needsSwap)
+
+### .opacity : number
+
+The opacity.
+
+Default is `1`.
+
+### .tCube : CubeTexture
+
+The cube texture to render.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever the pass is no longer used in your app.
+
+**Overrides:** [Pass#dispose](Pass.html#dispose)
+
+### .render( renderer : WebGLRenderer, writeBuffer : WebGLRenderTarget, readBuffer : WebGLRenderTarget, deltaTime : number, maskActive : boolean )
+
+Performs the cube texture pass.
+
+**renderer**
+
+The renderer.
+
+**writeBuffer**
+
+The write buffer. This buffer is intended as the rendering destination for the pass.
+
+**readBuffer**
+
+The read buffer. The pass can access the result from the previous pass from this buffer.
+
+**deltaTime**
+
+The delta time in seconds.
+
+**maskActive**
+
+Whether masking is active or not.
+
+**Overrides:** [Pass#render](Pass.html#render)
+
+## Source
+
+[examples/jsm/postprocessing/CubeTexturePass.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/CubeTexturePass.js)
\ No newline at end of file
diff --git a/docs/pages/CubicBezierCurve.html.md b/docs/pages/CubicBezierCurve.html.md
new file mode 100644
index 00000000000000..2ba81bf2111817
--- /dev/null
+++ b/docs/pages/CubicBezierCurve.html.md
@@ -0,0 +1,89 @@
+*Inheritance: Curve →*
+
+# CubicBezierCurve
+
+A curve representing a 2D Cubic Bezier curve.
+
+## Code Example
+
+```js
+const curve = new THREE.CubicBezierCurve(
+ new THREE.Vector2( - 0, 0 ),
+ new THREE.Vector2( - 5, 15 ),
+ new THREE.Vector2( 20, 15 ),
+ new THREE.Vector2( 10, 0 )
+);
+const points = curve.getPoints( 50 );
+const geometry = new THREE.BufferGeometry().setFromPoints( points );
+const material = new THREE.LineBasicMaterial( { color: 0xff0000 } );
+// Create the final object to add to the scene
+const curveObject = new THREE.Line( geometry, material );
+```
+
+## Constructor
+
+### new CubicBezierCurve( v0 : Vector2, v1 : Vector2, v2 : Vector2, v3 : Vector2 )
+
+Constructs a new Cubic Bezier curve.
+
+**v0**
+
+The start point.
+
+**v1**
+
+The first control point.
+
+**v2**
+
+The second control point.
+
+**v3**
+
+The end point.
+
+## Properties
+
+### .isCubicBezierCurve : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .v0 : Vector2
+
+The start point.
+
+### .v1 : Vector2
+
+The first control point.
+
+### .v2 : Vector2
+
+The second control point.
+
+### .v3 : Vector2
+
+The end point.
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector2 ) : Vector2
+
+Returns a point on the curve.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve.
+
+## Source
+
+[src/extras/curves/CubicBezierCurve.js](https://github.com/mrdoob/three.js/blob/master/src/extras/curves/CubicBezierCurve.js)
\ No newline at end of file
diff --git a/docs/pages/CubicBezierCurve3.html.md b/docs/pages/CubicBezierCurve3.html.md
new file mode 100644
index 00000000000000..e78f3a42144bc2
--- /dev/null
+++ b/docs/pages/CubicBezierCurve3.html.md
@@ -0,0 +1,73 @@
+*Inheritance: Curve →*
+
+# CubicBezierCurve3
+
+A curve representing a 3D Cubic Bezier curve.
+
+## Constructor
+
+### new CubicBezierCurve3( v0 : Vector3, v1 : Vector3, v2 : Vector3, v3 : Vector3 )
+
+Constructs a new Cubic Bezier curve.
+
+**v0**
+
+The start point.
+
+**v1**
+
+The first control point.
+
+**v2**
+
+The second control point.
+
+**v3**
+
+The end point.
+
+## Properties
+
+### .isCubicBezierCurve3 : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .v0 : Vector3
+
+The start point.
+
+### .v1 : Vector3
+
+The first control point.
+
+### .v2 : Vector3
+
+The second control point.
+
+### .v3 : Vector3
+
+The end point.
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector3 ) : Vector3
+
+Returns a point on the curve.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve.
+
+## Source
+
+[src/extras/curves/CubicBezierCurve3.js](https://github.com/mrdoob/three.js/blob/master/src/extras/curves/CubicBezierCurve3.js)
\ No newline at end of file
diff --git a/docs/pages/CubicInterpolant.html.md b/docs/pages/CubicInterpolant.html.md
new file mode 100644
index 00000000000000..b5c394a2c457c4
--- /dev/null
+++ b/docs/pages/CubicInterpolant.html.md
@@ -0,0 +1,33 @@
+*Inheritance: Interpolant →*
+
+# CubicInterpolant
+
+Fast and simple cubic spline interpolant.
+
+It was derived from a Hermitian construction setting the first derivative at each sample position to the linear slope between neighboring positions over their parameter interval.
+
+## Constructor
+
+### new CubicInterpolant( parameterPositions : TypedArray, sampleValues : TypedArray, sampleSize : number, resultBuffer : TypedArray )
+
+Constructs a new cubic interpolant.
+
+**parameterPositions**
+
+The parameter positions hold the interpolation factors.
+
+**sampleValues**
+
+The sample values.
+
+**sampleSize**
+
+The sample size
+
+**resultBuffer**
+
+The result buffer.
+
+## Source
+
+[src/math/interpolants/CubicInterpolant.js](https://github.com/mrdoob/three.js/blob/master/src/math/interpolants/CubicInterpolant.js)
\ No newline at end of file
diff --git a/docs/pages/Curve.html.md b/docs/pages/Curve.html.md
new file mode 100644
index 00000000000000..834cb0a6e934fb
--- /dev/null
+++ b/docs/pages/Curve.html.md
@@ -0,0 +1,207 @@
+# Curve
+
+An abstract base class for creating an analytic curve object that contains methods for interpolation.
+
+## Constructor
+
+### new Curve() (abstract)
+
+Constructs a new curve.
+
+## Properties
+
+### .arcLengthDivisions : number
+
+This value determines the amount of divisions when calculating the cumulative segment lengths of a curve via [Curve#getLengths](Curve.html#getLengths). To ensure precision when using methods like [Curve#getSpacedPoints](Curve.html#getSpacedPoints), it is recommended to increase the value of this property if the curve is very large.
+
+Default is `200`.
+
+### .needsUpdate : boolean
+
+Must be set to `true` if the curve parameters have changed.
+
+Default is `false`.
+
+### .type : string (readonly)
+
+The type property is used for detecting the object type in context of serialization/deserialization.
+
+## Methods
+
+### .clone() : Curve
+
+Returns a new curve with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .computeFrenetFrames( segments : number, closed : boolean ) : Object
+
+Generates the Frenet Frames. Requires a curve definition in 3D space. Used in geometries like [TubeGeometry](TubeGeometry.html) or [ExtrudeGeometry](ExtrudeGeometry.html).
+
+**segments**
+
+The number of segments.
+
+**closed**
+
+Whether the curve is closed or not.
+
+Default is `false`.
+
+**Returns:** The Frenet Frames.
+
+### .copy( source : Curve ) : Curve
+
+Copies the values of the given curve to this instance.
+
+**source**
+
+The curve to copy.
+
+**Returns:** A reference to this curve.
+
+### .fromJSON( json : Object ) : Curve
+
+Deserializes the curve from the given JSON.
+
+**json**
+
+The JSON holding the serialized curve.
+
+**Returns:** A reference to this curve.
+
+### .getLength() : number
+
+Returns the total arc length of the curve.
+
+**Returns:** The length of the curve.
+
+### .getLengths( divisions : number ) : Array.
+
+Returns an array of cumulative segment lengths of the curve.
+
+**divisions**
+
+The number of divisions.
+
+Default is `this.arcLengthDivisions`.
+
+**Returns:** An array holding the cumulative segment lengths.
+
+### .getPoint( t : number, optionalTarget : Vector2 | Vector3 ) : Vector2 | Vector3 (abstract)
+
+This method returns a vector in 2D or 3D space (depending on the curve definition) for the given interpolation factor.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Returns:** The position on the curve. It can be a 2D or 3D vector depending on the curve definition.
+
+### .getPointAt( u : number, optionalTarget : Vector2 | Vector3 ) : Vector2 | Vector3
+
+This method returns a vector in 2D or 3D space (depending on the curve definition) for the given interpolation factor. Unlike [Curve#getPoint](Curve.html#getPoint), this method honors the length of the curve which equidistant samples.
+
+**u**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Returns:** The position on the curve. It can be a 2D or 3D vector depending on the curve definition.
+
+### .getPoints( divisions : number ) : Array.<(Vector2|Vector3)>
+
+This method samples the curve via [Curve#getPoint](Curve.html#getPoint) and returns an array of points representing the curve shape.
+
+**divisions**
+
+The number of divisions.
+
+Default is `5`.
+
+**Returns:** An array holding the sampled curve values. The number of points is `divisions + 1`.
+
+### .getSpacedPoints( divisions : number ) : Array.<(Vector2|Vector3)>
+
+This method samples the curve via [Curve#getPointAt](Curve.html#getPointAt) and returns an array of points representing the curve shape. Unlike [Curve#getPoints](Curve.html#getPoints), this method returns equi-spaced points across the entire curve.
+
+**divisions**
+
+The number of divisions.
+
+Default is `5`.
+
+**Returns:** An array holding the sampled curve values. The number of points is `divisions + 1`.
+
+### .getTangent( t : number, optionalTarget : Vector2 | Vector3 ) : Vector2 | Vector3
+
+Returns a unit vector tangent for the given interpolation factor. If the derived curve does not implement its tangent derivation, two points a small delta apart will be used to find its gradient which seems to give a reasonable approximation.
+
+**t**
+
+The interpolation factor.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Returns:** The tangent vector.
+
+### .getTangentAt( u : number, optionalTarget : Vector2 | Vector3 ) : Vector2 | Vector3
+
+Same as [Curve#getTangent](Curve.html#getTangent) but with equidistant samples.
+
+**u**
+
+The interpolation factor.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+See:
+
+* [Curve#getPointAt](Curve.html#getPointAt)
+
+**Returns:** The tangent vector.
+
+### .getUtoTmapping( u : number, distance : number ) : number
+
+Given an interpolation factor in the range `[0,1]`, this method returns an updated interpolation factor in the same range that can be ued to sample equidistant points from a curve.
+
+**u**
+
+The interpolation factor.
+
+**distance**
+
+An optional distance on the curve.
+
+Default is `null`.
+
+**Returns:** The updated interpolation factor.
+
+### .toJSON() : Object
+
+Serializes the curve into JSON.
+
+See:
+
+* [ObjectLoader#parse](ObjectLoader.html#parse)
+
+**Returns:** A JSON object representing the serialized curve.
+
+### .updateArcLengths()
+
+Update the cumulative segment distance cache. The method must be called every time curve parameters are changed. If an updated curve is part of a composed curve like [CurvePath](CurvePath.html), this method must be called on the composed curve, too.
+
+## Source
+
+[src/extras/core/Curve.js](https://github.com/mrdoob/three.js/blob/master/src/extras/core/Curve.js)
\ No newline at end of file
diff --git a/docs/pages/CurvePath.html.md b/docs/pages/CurvePath.html.md
new file mode 100644
index 00000000000000..e81ee8164d46dc
--- /dev/null
+++ b/docs/pages/CurvePath.html.md
@@ -0,0 +1,65 @@
+*Inheritance: Curve →*
+
+# CurvePath
+
+A base class extending [Curve](Curve.html). `CurvePath` is simply an array of connected curves, but retains the API of a curve.
+
+## Constructor
+
+### new CurvePath()
+
+Constructs a new curve path.
+
+## Properties
+
+### .autoClose : boolean
+
+Whether the path should automatically be closed by a line curve.
+
+Default is `false`.
+
+### .curves : Array.
+
+An array of curves defining the path.
+
+## Methods
+
+### .add( curve : Curve )
+
+Adds a curve to this curve path.
+
+**curve**
+
+The curve to add.
+
+### .closePath() : CurvePath
+
+Adds a line curve to close the path.
+
+**Returns:** A reference to this curve path.
+
+### .getCurveLengths() : Array.
+
+Returns list of cumulative curve lengths of the defined curves.
+
+**Returns:** The curve lengths.
+
+### .getPoint( t : number, optionalTarget : Vector2 | Vector3 ) : Vector2 | Vector3
+
+This method returns a vector in 2D or 3D space (depending on the curve definitions) for the given interpolation factor.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve. It can be a 2D or 3D vector depending on the curve definition.
+
+## Source
+
+[src/extras/core/CurvePath.js](https://github.com/mrdoob/three.js/blob/master/src/extras/core/CurvePath.js)
\ No newline at end of file
diff --git a/docs/pages/CylinderGeometry.html.md b/docs/pages/CylinderGeometry.html.md
new file mode 100644
index 00000000000000..b328d75ed5cf3c
--- /dev/null
+++ b/docs/pages/CylinderGeometry.html.md
@@ -0,0 +1,90 @@
+*Inheritance: EventDispatcher → BufferGeometry →*
+
+# CylinderGeometry
+
+A geometry class for representing a cylinder.
+
+## Code Example
+
+```js
+const geometry = new THREE.CylinderGeometry( 5, 5, 20, 32 );
+const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
+const cylinder = new THREE.Mesh( geometry, material );
+scene.add( cylinder );
+```
+
+## Constructor
+
+### new CylinderGeometry( radiusTop : number, radiusBottom : number, height : number, radialSegments : number, heightSegments : number, openEnded : boolean, thetaStart : number, thetaLength : number )
+
+Constructs a new cylinder geometry.
+
+**radiusTop**
+
+Radius of the cylinder at the top.
+
+Default is `1`.
+
+**radiusBottom**
+
+Radius of the cylinder at the bottom.
+
+Default is `1`.
+
+**height**
+
+Height of the cylinder.
+
+Default is `1`.
+
+**radialSegments**
+
+Number of segmented faces around the circumference of the cylinder.
+
+Default is `32`.
+
+**heightSegments**
+
+Number of rows of faces along the height of the cylinder.
+
+Default is `1`.
+
+**openEnded**
+
+Whether the base of the cylinder is open or capped.
+
+Default is `false`.
+
+**thetaStart**
+
+Start angle for first segment, in radians.
+
+Default is `0`.
+
+**thetaLength**
+
+The central angle, often called theta, of the circular sector, in radians. The default value results in a complete cylinder.
+
+Default is `Math.PI*2`.
+
+## Properties
+
+### .parameters : Object
+
+Holds the constructor parameters that have been used to generate the geometry. Any modification after instantiation does not change the geometry.
+
+## Static Methods
+
+### .fromJSON( data : Object ) : CylinderGeometry
+
+Factory method for creating an instance of this class from the given JSON object.
+
+**data**
+
+A JSON object representing the serialized geometry.
+
+**Returns:** A new instance.
+
+## Source
+
+[src/geometries/CylinderGeometry.js](https://github.com/mrdoob/three.js/blob/master/src/geometries/CylinderGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/Cylindrical.html.md b/docs/pages/Cylindrical.html.md
new file mode 100644
index 00000000000000..62884737442414
--- /dev/null
+++ b/docs/pages/Cylindrical.html.md
@@ -0,0 +1,115 @@
+# Cylindrical
+
+This class can be used to represent points in 3D space as [Cylindrical coordinates](https://en.wikipedia.org/wiki/Cylindrical_coordinate_system).
+
+## Constructor
+
+### new Cylindrical( radius : number, theta : number, y : number )
+
+Constructs a new cylindrical.
+
+**radius**
+
+The distance from the origin to a point in the x-z plane.
+
+Default is `1`.
+
+**theta**
+
+A counterclockwise angle in the x-z plane measured in radians from the positive z-axis.
+
+Default is `0`.
+
+**y**
+
+The height above the x-z plane.
+
+Default is `0`.
+
+## Properties
+
+### .radius : number
+
+The distance from the origin to a point in the x-z plane.
+
+Default is `1`.
+
+### .theta : number
+
+A counterclockwise angle in the x-z plane measured in radians from the positive z-axis.
+
+Default is `0`.
+
+### .y : number
+
+The height above the x-z plane.
+
+Default is `0`.
+
+## Methods
+
+### .clone() : Cylindrical
+
+Returns a new cylindrical with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .copy( other : Cylindrical ) : Cylindrical
+
+Copies the values of the given cylindrical to this instance.
+
+**other**
+
+The cylindrical to copy.
+
+**Returns:** A reference to this cylindrical.
+
+### .set( radius : number, theta : number, y : number ) : Cylindrical
+
+Sets the cylindrical components by copying the given values.
+
+**radius**
+
+The radius.
+
+**theta**
+
+The theta angle.
+
+**y**
+
+The height value.
+
+**Returns:** A reference to this cylindrical.
+
+### .setFromCartesianCoords( x : number, y : number, z : number ) : Cylindrical
+
+Sets the cylindrical components from the given Cartesian coordinates.
+
+**x**
+
+The x value.
+
+**y**
+
+The x value.
+
+**z**
+
+The x value.
+
+**Returns:** A reference to this cylindrical.
+
+### .setFromVector3( v : Vector3 ) : Cylindrical
+
+Sets the cylindrical components from the given vector which is assumed to hold Cartesian coordinates.
+
+**v**
+
+The vector to set.
+
+**Returns:** A reference to this cylindrical.
+
+## Source
+
+[src/math/Cylindrical.js](https://github.com/mrdoob/three.js/blob/master/src/math/Cylindrical.js)
\ No newline at end of file
diff --git a/docs/pages/DDSLoader.html.md b/docs/pages/DDSLoader.html.md
new file mode 100644
index 00000000000000..013f0f01152b4c
--- /dev/null
+++ b/docs/pages/DDSLoader.html.md
@@ -0,0 +1,53 @@
+*Inheritance: Loader → CompressedTextureLoader →*
+
+# DDSLoader
+
+A loader for the S3TC texture compression format.
+
+## Code Example
+
+```js
+const loader = new DDSLoader();
+const map = loader.load( 'textures/compressed/disturb_dxt1_nomip.dds' );
+map.colorSpace = THREE.SRGBColorSpace; // only for color textures
+```
+
+## Import
+
+DDSLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { DDSLoader } from 'three/addons/loaders/DDSLoader.js';
+```
+
+## Constructor
+
+### new DDSLoader( manager : LoadingManager )
+
+Constructs a new DDS loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .parse( buffer : ArrayBuffer, loadMipmaps : boolean ) : CompressedTextureLoader~TexData
+
+Parses the given S3TC texture data.
+
+**buffer**
+
+The raw texture data.
+
+**loadMipmaps**
+
+Whether to load mipmaps or not.
+
+**Overrides:** [CompressedTextureLoader#parse](CompressedTextureLoader.html#parse)
+
+**Returns:** An object representing the parsed texture data.
+
+## Source
+
+[examples/jsm/loaders/DDSLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/DDSLoader.js)
\ No newline at end of file
diff --git a/docs/pages/DRACOExporter.html.md b/docs/pages/DRACOExporter.html.md
new file mode 100644
index 00000000000000..8c03e8ff560014
--- /dev/null
+++ b/docs/pages/DRACOExporter.html.md
@@ -0,0 +1,115 @@
+# DRACOExporter
+
+An exporter to compress geometry with the Draco library.
+
+[Draco](https://google.github.io/draco/) is an open source library for compressing and decompressing 3D meshes and point clouds. Compressed geometry can be significantly smaller, at the cost of additional decoding time on the client device.
+
+Standalone Draco files have a `.drc` extension, and contain vertex positions, normals, colors, and other attributes. Draco files _do not_ contain materials, textures, animation, or node hierarchies – to use these features, embed Draco geometry inside of a glTF file. A normal glTF file can be converted to a Draco-compressed glTF file using [glTF-Pipeline](https://github.com/AnalyticalGraphicsInc/gltf-pipeline).
+
+## Code Example
+
+```js
+const exporter = new DRACOExporter();
+const data = exporter.parse( mesh, options );
+```
+
+## Import
+
+DRACOExporter is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { DRACOExporter } from 'three/addons/exporters/DRACOExporter.js';
+```
+
+## Constructor
+
+### new DRACOExporter()
+
+## Properties
+
+### .MESH_EDGEBREAKER_ENCODING : number (constant)
+
+Edgebreaker encoding.
+
+Default is `1`.
+
+### .MESH_SEQUENTIAL_ENCODING : number (constant)
+
+Sequential encoding.
+
+Default is `0`.
+
+## Methods
+
+### .parse( object : Mesh | Points, options : DRACOExporter~Options ) : Int8Array
+
+Parses the given mesh or point cloud and generates the Draco output.
+
+**object**
+
+The mesh or point cloud to export.
+
+**options**
+
+The export options.
+
+**Returns:** The exported Draco.
+
+## Type Definitions
+
+### .Options
+
+Export options of `DRACOExporter`.
+
+**decodeSpeed**
+number
+
+Indicates how to tune the encoder regarding decode speed (0 gives better speed but worst quality).
+
+Default is `5`.
+
+**encodeSpeed**
+number
+
+Indicates how to tune the encoder parameters (0 gives better speed but worst quality).
+
+Default is `5`.
+
+**encoderMethod**
+number
+
+Either sequential (very little compression) or Edgebreaker. Edgebreaker traverses the triangles of the mesh in a deterministic, spiral-like way which provides most of the benefits of this data format.
+
+Default is `1`.
+
+**quantization**
+Array.
+
+Indicates the precision of each type of data stored in the draco file in the order (POSITION, NORMAL, COLOR, TEX\_COORD, GENERIC).
+
+Default is `[ 16, 8, 8, 8, 8 ]`.
+
+**exportUvs**
+boolean
+
+Whether to export UVs or not.
+
+Default is `true`.
+
+**exportNormals**
+boolean
+
+Whether to export normals or not.
+
+Default is `true`.
+
+**exportColor**
+boolean
+
+Whether to export colors or not.
+
+Default is `false`.
+
+## Source
+
+[examples/jsm/exporters/DRACOExporter.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/exporters/DRACOExporter.js)
\ No newline at end of file
diff --git a/docs/pages/DRACOLoader.html.md b/docs/pages/DRACOLoader.html.md
new file mode 100644
index 00000000000000..ee9fc49b6f23b8
--- /dev/null
+++ b/docs/pages/DRACOLoader.html.md
@@ -0,0 +1,117 @@
+*Inheritance: Loader →*
+
+# DRACOLoader
+
+A loader for the Draco format.
+
+[Draco](https://google.github.io/draco/) is an open source library for compressing and decompressing 3D meshes and point clouds. Compressed geometry can be significantly smaller, at the cost of additional decoding time on the client device.
+
+Standalone Draco files have a `.drc` extension, and contain vertex positions, normals, colors, and other attributes. Draco files do not contain materials, textures, animation, or node hierarchies – to use these features, embed Draco geometry inside of a glTF file. A normal glTF file can be converted to a Draco-compressed glTF file using [glTF-Pipeline](https://github.com/CesiumGS/gltf-pipeline). When using Draco with glTF, an instance of `DRACOLoader` will be used internally by [GLTFLoader](GLTFLoader.html).
+
+It is recommended to create one DRACOLoader instance and reuse it to avoid loading and creating multiple decoder instances.
+
+`DRACOLoader` will automatically use either the JS or the WASM decoding library, based on browser capabilities.
+
+## Code Example
+
+```js
+const loader = new DRACOLoader();
+loader.setDecoderPath( '/examples/jsm/libs/draco/' );
+const geometry = await dracoLoader.loadAsync( 'models/draco/bunny.drc' );
+geometry.computeVertexNormals(); // optional
+dracoLoader.dispose();
+```
+
+## Import
+
+DRACOLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { DRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
+```
+
+## Constructor
+
+### new DRACOLoader( manager : LoadingManager )
+
+Constructs a new Draco loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded Draco asset to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( buffer : ArrayBuffer, onLoad : function, onError : onErrorCallback )
+
+Parses the given Draco data.
+
+**buffer**
+
+The raw Draco data as an array buffer.
+
+**onLoad**
+
+Executed when the loading/parsing process has been finished.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+### .setDecoderConfig( config : Object ) : DRACOLoader
+
+Provides configuration for the decoder libraries. Configuration cannot be changed after decoding begins.
+
+**config**
+
+The decoder config.
+
+**Returns:** A reference to this loader.
+
+### .setDecoderPath( path : string ) : DRACOLoader
+
+Provides configuration for the decoder libraries. Configuration cannot be changed after decoding begins.
+
+**path**
+
+The decoder path.
+
+**Returns:** A reference to this loader.
+
+### .setWorkerLimit( workerLimit : number ) : DRACOLoader
+
+Sets the maximum number of Web Workers to be used during decoding. A lower limit may be preferable if workers are also for other tasks in the application.
+
+**workerLimit**
+
+The worker limit.
+
+**Returns:** A reference to this loader.
+
+## Source
+
+[examples/jsm/loaders/DRACOLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/DRACOLoader.js)
\ No newline at end of file
diff --git a/docs/pages/Data3DTexture.html.md b/docs/pages/Data3DTexture.html.md
new file mode 100644
index 00000000000000..227564401b853f
--- /dev/null
+++ b/docs/pages/Data3DTexture.html.md
@@ -0,0 +1,109 @@
+*Inheritance: EventDispatcher → Texture →*
+
+# Data3DTexture
+
+Creates a three-dimensional texture from raw data, with parameters to divide it into width, height, and depth.
+
+## Constructor
+
+### new Data3DTexture( data : TypedArray, width : number, height : number, depth : number )
+
+Constructs a new data array texture.
+
+**data**
+
+The buffer data.
+
+Default is `null`.
+
+**width**
+
+The width of the texture.
+
+Default is `1`.
+
+**height**
+
+The height of the texture.
+
+Default is `1`.
+
+**depth**
+
+The depth of the texture.
+
+Default is `1`.
+
+## Properties
+
+### .flipY : boolean
+
+If set to `true`, the texture is flipped along the vertical axis when uploaded to the GPU.
+
+Overwritten and set to `false` by default.
+
+Default is `false`.
+
+**Overrides:** [Texture#flipY](Texture.html#flipY)
+
+### .generateMipmaps : boolean
+
+Whether to generate mipmaps (if possible) for a texture.
+
+Overwritten and set to `false` by default.
+
+Default is `false`.
+
+**Overrides:** [Texture#generateMipmaps](Texture.html#generateMipmaps)
+
+### .image : Object
+
+The image definition of a data texture.
+
+**Overrides:** [Texture#image](Texture.html#image)
+
+### .isData3DTexture : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .magFilter : NearestFilter | NearestMipmapNearestFilter | NearestMipmapLinearFilter | LinearFilter | LinearMipmapNearestFilter | LinearMipmapLinearFilter
+
+How the texture is sampled when a texel covers more than one pixel.
+
+Overwritten and set to `NearestFilter` by default.
+
+Default is `NearestFilter`.
+
+**Overrides:** [Texture#magFilter](Texture.html#magFilter)
+
+### .minFilter : NearestFilter | NearestMipmapNearestFilter | NearestMipmapLinearFilter | LinearFilter | LinearMipmapNearestFilter | LinearMipmapLinearFilter
+
+How the texture is sampled when a texel covers less than one pixel.
+
+Overwritten and set to `NearestFilter` by default.
+
+Default is `NearestFilter`.
+
+**Overrides:** [Texture#minFilter](Texture.html#minFilter)
+
+### .unpackAlignment : boolean
+
+Specifies the alignment requirements for the start of each pixel row in memory.
+
+Overwritten and set to `1` by default.
+
+Default is `1`.
+
+**Overrides:** [Texture#unpackAlignment](Texture.html#unpackAlignment)
+
+### .wrapR : RepeatWrapping | ClampToEdgeWrapping | MirroredRepeatWrapping
+
+This defines how the texture is wrapped in the depth and corresponds to _W_ in UVW mapping.
+
+Default is `ClampToEdgeWrapping`.
+
+## Source
+
+[src/textures/Data3DTexture.js](https://github.com/mrdoob/three.js/blob/master/src/textures/Data3DTexture.js)
\ No newline at end of file
diff --git a/docs/pages/DataArrayTexture.html.md b/docs/pages/DataArrayTexture.html.md
new file mode 100644
index 00000000000000..b294fc99356e2e
--- /dev/null
+++ b/docs/pages/DataArrayTexture.html.md
@@ -0,0 +1,127 @@
+*Inheritance: EventDispatcher → Texture →*
+
+# DataArrayTexture
+
+Creates an array of textures directly from raw buffer data.
+
+## Constructor
+
+### new DataArrayTexture( data : TypedArray, width : number, height : number, depth : number )
+
+Constructs a new data array texture.
+
+**data**
+
+The buffer data.
+
+Default is `null`.
+
+**width**
+
+The width of the texture.
+
+Default is `1`.
+
+**height**
+
+The height of the texture.
+
+Default is `1`.
+
+**depth**
+
+The depth of the texture.
+
+Default is `1`.
+
+## Properties
+
+### .flipY : boolean
+
+If set to `true`, the texture is flipped along the vertical axis when uploaded to the GPU.
+
+Overwritten and set to `false` by default.
+
+Default is `false`.
+
+**Overrides:** [Texture#flipY](Texture.html#flipY)
+
+### .generateMipmaps : boolean
+
+Whether to generate mipmaps (if possible) for a texture.
+
+Overwritten and set to `false` by default.
+
+Default is `false`.
+
+**Overrides:** [Texture#generateMipmaps](Texture.html#generateMipmaps)
+
+### .image : Object
+
+The image definition of a data texture.
+
+**Overrides:** [Texture#image](Texture.html#image)
+
+### .isDataArrayTexture : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .layerUpdates : Set.
+
+A set of all layers which need to be updated in the texture.
+
+### .magFilter : NearestFilter | NearestMipmapNearestFilter | NearestMipmapLinearFilter | LinearFilter | LinearMipmapNearestFilter | LinearMipmapLinearFilter
+
+How the texture is sampled when a texel covers more than one pixel.
+
+Overwritten and set to `NearestFilter` by default.
+
+Default is `NearestFilter`.
+
+**Overrides:** [Texture#magFilter](Texture.html#magFilter)
+
+### .minFilter : NearestFilter | NearestMipmapNearestFilter | NearestMipmapLinearFilter | LinearFilter | LinearMipmapNearestFilter | LinearMipmapLinearFilter
+
+How the texture is sampled when a texel covers less than one pixel.
+
+Overwritten and set to `NearestFilter` by default.
+
+Default is `NearestFilter`.
+
+**Overrides:** [Texture#minFilter](Texture.html#minFilter)
+
+### .unpackAlignment : boolean
+
+Specifies the alignment requirements for the start of each pixel row in memory.
+
+Overwritten and set to `1` by default.
+
+Default is `1`.
+
+**Overrides:** [Texture#unpackAlignment](Texture.html#unpackAlignment)
+
+### .wrapR : RepeatWrapping | ClampToEdgeWrapping | MirroredRepeatWrapping
+
+This defines how the texture is wrapped in the depth and corresponds to _W_ in UVW mapping.
+
+Default is `ClampToEdgeWrapping`.
+
+## Methods
+
+### .addLayerUpdate( layerIndex : number )
+
+Describes that a specific layer of the texture needs to be updated. Normally when [Texture#needsUpdate](Texture.html#needsUpdate) is set to `true`, the entire data texture array is sent to the GPU. Marking specific layers will only transmit subsets of all mipmaps associated with a specific depth in the array which is often much more performant.
+
+**layerIndex**
+
+The layer index that should be updated.
+
+### .clearLayerUpdates()
+
+Resets the layer updates registry.
+
+## Source
+
+[src/textures/DataArrayTexture.js](https://github.com/mrdoob/three.js/blob/master/src/textures/DataArrayTexture.js)
\ No newline at end of file
diff --git a/docs/pages/DataTexture.html.md b/docs/pages/DataTexture.html.md
new file mode 100644
index 00000000000000..7002705cf05012
--- /dev/null
+++ b/docs/pages/DataTexture.html.md
@@ -0,0 +1,133 @@
+*Inheritance: EventDispatcher → Texture →*
+
+# DataTexture
+
+Creates a texture directly from raw buffer data.
+
+The interpretation of the data depends on type and format: If the type is `UnsignedByteType`, a `Uint8Array` will be useful for addressing the texel data. If the format is `RGBAFormat`, data needs four values for one texel; Red, Green, Blue and Alpha (typically the opacity).
+
+## Constructor
+
+### new DataTexture( data : TypedArray, width : number, height : number, format : number, type : number, mapping : number, wrapS : number, wrapT : number, magFilter : number, minFilter : number, anisotropy : number, colorSpace : string )
+
+Constructs a new data texture.
+
+**data**
+
+The buffer data.
+
+Default is `null`.
+
+**width**
+
+The width of the texture.
+
+Default is `1`.
+
+**height**
+
+The height of the texture.
+
+Default is `1`.
+
+**format**
+
+The texture format.
+
+Default is `RGBAFormat`.
+
+**type**
+
+The texture type.
+
+Default is `UnsignedByteType`.
+
+**mapping**
+
+The texture mapping.
+
+Default is `Texture.DEFAULT_MAPPING`.
+
+**wrapS**
+
+The wrapS value.
+
+Default is `ClampToEdgeWrapping`.
+
+**wrapT**
+
+The wrapT value.
+
+Default is `ClampToEdgeWrapping`.
+
+**magFilter**
+
+The mag filter value.
+
+Default is `NearestFilter`.
+
+**minFilter**
+
+The min filter value.
+
+Default is `NearestFilter`.
+
+**anisotropy**
+
+The anisotropy value.
+
+Default is `Texture.DEFAULT_ANISOTROPY`.
+
+**colorSpace**
+
+The color space.
+
+Default is `NoColorSpace`.
+
+## Properties
+
+### .flipY : boolean
+
+If set to `true`, the texture is flipped along the vertical axis when uploaded to the GPU.
+
+Overwritten and set to `false` by default.
+
+Default is `false`.
+
+**Overrides:** [Texture#flipY](Texture.html#flipY)
+
+### .generateMipmaps : boolean
+
+Whether to generate mipmaps (if possible) for a texture.
+
+Overwritten and set to `false` by default.
+
+Default is `false`.
+
+**Overrides:** [Texture#generateMipmaps](Texture.html#generateMipmaps)
+
+### .image : Object
+
+The image definition of a data texture.
+
+**Overrides:** [Texture#image](Texture.html#image)
+
+### .isDataTexture : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .unpackAlignment : boolean
+
+Specifies the alignment requirements for the start of each pixel row in memory.
+
+Overwritten and set to `1` by default.
+
+Default is `1`.
+
+**Overrides:** [Texture#unpackAlignment](Texture.html#unpackAlignment)
+
+## Source
+
+[src/textures/DataTexture.js](https://github.com/mrdoob/three.js/blob/master/src/textures/DataTexture.js)
\ No newline at end of file
diff --git a/docs/pages/DataTextureLoader.html.md b/docs/pages/DataTextureLoader.html.md
new file mode 100644
index 00000000000000..eff5fffc2ce9dc
--- /dev/null
+++ b/docs/pages/DataTextureLoader.html.md
@@ -0,0 +1,134 @@
+*Inheritance: Loader →*
+
+# DataTextureLoader
+
+Abstract base class for loading binary texture formats RGBE, EXR or TGA. Textures are internally loaded via [FileLoader](FileLoader.html).
+
+Derived classes have to implement the `parse()` method which holds the parsing for the respective format.
+
+## Constructor
+
+### new DataTextureLoader( manager : LoadingManager ) (abstract)
+
+Constructs a new data texture loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback ) : DataTexture
+
+Starts loading from the given URL and passes the loaded data texture to the `onLoad()` callback. The method also returns a new texture object which can directly be used for material creation. If you do it this way, the texture may pop up in your scene once the respective loading process is finished.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+**Returns:** The data texture.
+
+## Type Definitions
+
+### .TexData
+
+Represents the result object type of the `parse()` method.
+
+**image**
+Object
+
+An object holding width, height and the texture data.
+
+**width**
+number
+
+The width of the base mip.
+
+**height**
+number
+
+The width of the base mip.
+
+**data**
+TypedArray
+
+The texture data.
+
+**format**
+number
+
+The texture format.
+
+**type**
+number
+
+The texture type.
+
+**flipY**
+boolean
+
+If set to `true`, the texture is flipped along the vertical axis when uploaded to the GPU.
+
+**wrapS**
+number
+
+The wrapS value.
+
+Default is `ClampToEdgeWrapping`.
+
+**wrapT**
+number
+
+The wrapT value.
+
+Default is `ClampToEdgeWrapping`.
+
+**anisotropy**
+number
+
+The anisotropy value.
+
+Default is `1`.
+
+**generateMipmaps**
+boolean
+
+Whether to generate mipmaps or not.
+
+**colorSpace**
+string
+
+The color space.
+
+**magFilter**
+number
+
+The mag filter.
+
+**minFilter**
+number
+
+The min filter.
+
+**mipmaps**
+Array.
+
+The mipmaps.
+
+## Source
+
+[src/loaders/DataTextureLoader.js](https://github.com/mrdoob/three.js/blob/master/src/loaders/DataTextureLoader.js)
\ No newline at end of file
diff --git a/docs/pages/DataUtils.html.md b/docs/pages/DataUtils.html.md
new file mode 100644
index 00000000000000..561a39916bf06b
--- /dev/null
+++ b/docs/pages/DataUtils.html.md
@@ -0,0 +1,29 @@
+# DataUtils
+
+A class containing utility functions for data.
+
+## Static Methods
+
+### .fromHalfFloat( val : number ) : number
+
+Returns a single precision floating point value (FP32) from the given half precision floating point value (FP16).
+
+**val**
+
+A half precision floating point value.
+
+**Returns:** The FP32 value.
+
+### .toHalfFloat( val : number ) : number
+
+Returns a half precision floating point value (FP16) from the given single precision floating point value (FP32).
+
+**val**
+
+A single precision floating point value.
+
+**Returns:** The FP16 value.
+
+## Source
+
+[src/extras/DataUtils.js](https://github.com/mrdoob/three.js/blob/master/src/extras/DataUtils.js)
\ No newline at end of file
diff --git a/docs/pages/DebugEnvironment.html.md b/docs/pages/DebugEnvironment.html.md
new file mode 100644
index 00000000000000..d2bbaf5220c286
--- /dev/null
+++ b/docs/pages/DebugEnvironment.html.md
@@ -0,0 +1,40 @@
+*Inheritance: EventDispatcher → Object3D → Scene →*
+
+# DebugEnvironment
+
+This class represents a scene with a very basic room setup that can be used as input for [PMREMGenerator#fromScene](PMREMGenerator.html#fromScene). The resulting PMREM represents the room's lighting and can be used for Image Based Lighting by assigning it to [Scene#environment](Scene.html#environment) or directly as an environment map to PBR materials.
+
+This class uses a simple room setup and should only be used for development purposes. A more appropriate setup for production is [RoomEnvironment](RoomEnvironment.html).
+
+## Code Example
+
+```js
+const environment = new DebugEnvironment();
+const pmremGenerator = new THREE.PMREMGenerator( renderer );
+const envMap = pmremGenerator.fromScene( environment ).texture;
+scene.environment = envMap;
+```
+
+## Import
+
+DebugEnvironment is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { DebugEnvironment } from 'three/addons/environments/DebugEnvironment.js';
+```
+
+## Constructor
+
+### new DebugEnvironment()
+
+Constructs a new debug environment.
+
+## Methods
+
+### .dispose()
+
+Frees internal resources. This method should be called when the environment is no longer required.
+
+## Source
+
+[examples/jsm/environments/DebugEnvironment.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/environments/DebugEnvironment.js)
\ No newline at end of file
diff --git a/docs/pages/DecalGeometry.html.md b/docs/pages/DecalGeometry.html.md
new file mode 100644
index 00000000000000..658f3049735efd
--- /dev/null
+++ b/docs/pages/DecalGeometry.html.md
@@ -0,0 +1,52 @@
+*Inheritance: EventDispatcher → BufferGeometry →*
+
+# DecalGeometry
+
+This class can be used to create a decal mesh that serves different kinds of purposes e.g. adding unique details to models, performing dynamic visual environmental changes or covering seams.
+
+Please not that decal projections can be distorted when used around corners. More information at this GitHub issue: [Decal projections without distortions](https://github.com/mrdoob/three.js/issues/21187).
+
+Reference: [How to project decals](http://blog.wolfire.com/2009/06/how-to-project-decals/)
+
+## Code Example
+
+```js
+const geometry = new DecalGeometry( mesh, position, orientation, size );
+const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
+const mesh = new THREE.Mesh( geometry, material );
+scene.add( mesh );
+```
+
+## Import
+
+DecalGeometry is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { DecalGeometry } from 'three/addons/geometries/DecalGeometry.js';
+```
+
+## Constructor
+
+### new DecalGeometry( mesh : Mesh, position : Vector3, orientation : Euler, size : Vector3 )
+
+Constructs a new decal geometry.
+
+**mesh**
+
+The base mesh the decal should be projected on.
+
+**position**
+
+The position of the decal projector.
+
+**orientation**
+
+The orientation of the decal projector.
+
+**size**
+
+The scale of the decal projector.
+
+## Source
+
+[examples/jsm/geometries/DecalGeometry.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/geometries/DecalGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/DecoratedTorusKnot4a.html.md b/docs/pages/DecoratedTorusKnot4a.html.md
new file mode 100644
index 00000000000000..99bda830b4be5c
--- /dev/null
+++ b/docs/pages/DecoratedTorusKnot4a.html.md
@@ -0,0 +1,55 @@
+*Inheritance: Curve →*
+
+# DecoratedTorusKnot4a
+
+A Decorated Torus Knot 4a.
+
+## Import
+
+DecoratedTorusKnot4a is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { DecoratedTorusKnot4a } from 'three/addons/curves/CurveExtras.js';
+```
+
+## Constructor
+
+### new DecoratedTorusKnot4a( scale : number )
+
+Constructs a new Decorated Torus Knot 4a.
+
+**scale**
+
+The curve's scale.
+
+Default is `1`.
+
+## Properties
+
+### .scale : number
+
+The curve's scale.
+
+Default is `40`.
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector3 ) : Vector3
+
+This method returns a vector in 3D space for the given interpolation factor.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve.
+
+## Source
+
+[examples/jsm/curves/CurveExtras.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/curves/CurveExtras.js)
\ No newline at end of file
diff --git a/docs/pages/DecoratedTorusKnot4b.html.md b/docs/pages/DecoratedTorusKnot4b.html.md
new file mode 100644
index 00000000000000..cd54a4d8181ccf
--- /dev/null
+++ b/docs/pages/DecoratedTorusKnot4b.html.md
@@ -0,0 +1,55 @@
+*Inheritance: Curve →*
+
+# DecoratedTorusKnot4b
+
+A Decorated Torus Knot 4b.
+
+## Import
+
+DecoratedTorusKnot4b is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { DecoratedTorusKnot4b } from 'three/addons/curves/CurveExtras.js';
+```
+
+## Constructor
+
+### new DecoratedTorusKnot4b( scale : number )
+
+Constructs a new Decorated Torus Knot 4b.
+
+**scale**
+
+The curve's scale.
+
+Default is `1`.
+
+## Properties
+
+### .scale : number
+
+The curve's scale.
+
+Default is `40`.
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector3 ) : Vector3
+
+This method returns a vector in 3D space for the given interpolation factor.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve.
+
+## Source
+
+[examples/jsm/curves/CurveExtras.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/curves/CurveExtras.js)
\ No newline at end of file
diff --git a/docs/pages/DecoratedTorusKnot5a.html.md b/docs/pages/DecoratedTorusKnot5a.html.md
new file mode 100644
index 00000000000000..2f9c6d7ebacabd
--- /dev/null
+++ b/docs/pages/DecoratedTorusKnot5a.html.md
@@ -0,0 +1,55 @@
+*Inheritance: Curve →*
+
+# DecoratedTorusKnot5a
+
+A Decorated Torus Knot 5a.
+
+## Import
+
+DecoratedTorusKnot5a is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { DecoratedTorusKnot5a } from 'three/addons/curves/CurveExtras.js';
+```
+
+## Constructor
+
+### new DecoratedTorusKnot5a( scale : number )
+
+Constructs a new Decorated Torus Knot 5a.
+
+**scale**
+
+The curve's scale.
+
+Default is `1`.
+
+## Properties
+
+### .scale : number
+
+The curve's scale.
+
+Default is `40`.
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector3 ) : Vector3
+
+This method returns a vector in 3D space for the given interpolation factor.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve.
+
+## Source
+
+[examples/jsm/curves/CurveExtras.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/curves/CurveExtras.js)
\ No newline at end of file
diff --git a/docs/pages/DecoratedTorusKnot5c.html.md b/docs/pages/DecoratedTorusKnot5c.html.md
new file mode 100644
index 00000000000000..5e80c45a371d50
--- /dev/null
+++ b/docs/pages/DecoratedTorusKnot5c.html.md
@@ -0,0 +1,55 @@
+*Inheritance: Curve →*
+
+# DecoratedTorusKnot5c
+
+A Decorated Torus Knot 5c.
+
+## Import
+
+DecoratedTorusKnot5c is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { DecoratedTorusKnot5c } from 'three/addons/curves/CurveExtras.js';
+```
+
+## Constructor
+
+### new DecoratedTorusKnot5c( scale : number )
+
+Constructs a new Decorated Torus Knot 5c.
+
+**scale**
+
+The curve's scale.
+
+Default is `1`.
+
+## Properties
+
+### .scale : number
+
+The curve's scale.
+
+Default is `40`.
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector3 ) : Vector3
+
+This method returns a vector in 3D space for the given interpolation factor.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve.
+
+## Source
+
+[examples/jsm/curves/CurveExtras.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/curves/CurveExtras.js)
\ No newline at end of file
diff --git a/docs/pages/DenoiseNode.html.md b/docs/pages/DenoiseNode.html.md
new file mode 100644
index 00000000000000..2b12c8a74994b4
--- /dev/null
+++ b/docs/pages/DenoiseNode.html.md
@@ -0,0 +1,109 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# DenoiseNode
+
+Post processing node for denoising data like raw screen-space ambient occlusion output. Denoise can noticeably improve the quality of ambient occlusion but also add quite some overhead to the post processing setup. It's best to make its usage optional (e.g. via graphic settings).
+
+Reference: [https://openaccess.thecvf.com/content/WACV2021/papers/Khademi\_Self-Supervised\_Poisson-Gaussian\_Denoising\_WACV\_2021\_paper.pdf](https://openaccess.thecvf.com/content/WACV2021/papers/Khademi_Self-Supervised_Poisson-Gaussian_Denoising_WACV_2021_paper.pdf).
+
+## Import
+
+DenoiseNode is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { denoise } from 'three/addons/tsl/display/DenoiseNode.js';
+```
+
+## Constructor
+
+### new DenoiseNode( textureNode : TextureNode, depthNode : Node., normalNode : Node., camera : Camera )
+
+Constructs a new denoise node.
+
+**textureNode**
+
+The texture node that represents the input of the effect (e.g. AO).
+
+**depthNode**
+
+A node that represents the scene's depth.
+
+**normalNode**
+
+A node that represents the scene's normals.
+
+**camera**
+
+The camera the scene is rendered with.
+
+## Properties
+
+### .depthNode : Node.
+
+A node that represents the scene's depth.
+
+### .depthPhi : UniformNode.
+
+The depth Phi value.
+
+### .index : UniformNode.
+
+The index.
+
+### .lumaPhi : UniformNode.
+
+The luma Phi value.
+
+### .noiseNode : TextureNode
+
+The node represents the internal noise texture.
+
+### .normalNode : Node.
+
+A node that represents the scene's normals. If no normals are passed to the constructor (because MRT is not available), normals can be automatically reconstructed from depth values in the shader.
+
+### .normalPhi : UniformNode.
+
+The normal Phi value.
+
+### .radius : UniformNode.
+
+The radius.
+
+### .textureNode : TextureNode
+
+The texture node that represents the input of the effect (e.g. AO).
+
+### .updateBeforeType : string
+
+The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node updates its internal uniforms once per frame in `updateBefore()`.
+
+Default is `'frame'`.
+
+**Overrides:** [TempNode#updateBeforeType](TempNode.html#updateBeforeType)
+
+## Methods
+
+### .setup( builder : NodeBuilder ) : ShaderCallNodeInternal
+
+This method is used to setup the effect's TSL code.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#setup](TempNode.html#setup)
+
+### .updateBefore( frame : NodeFrame )
+
+This method is used to update internal uniforms once per frame.
+
+**frame**
+
+The current node frame.
+
+**Overrides:** [TempNode#updateBefore](TempNode.html#updateBefore)
+
+## Source
+
+[examples/jsm/tsl/display/DenoiseNode.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/tsl/display/DenoiseNode.js)
\ No newline at end of file
diff --git a/docs/pages/DepthOfFieldNode.html.md b/docs/pages/DepthOfFieldNode.html.md
new file mode 100644
index 00000000000000..a463f6519c795d
--- /dev/null
+++ b/docs/pages/DepthOfFieldNode.html.md
@@ -0,0 +1,124 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# DepthOfFieldNode
+
+Post processing node for creating depth of field (DOF) effect.
+
+References:
+
+* [https://pixelmischiefblog.wordpress.com/2016/11/25/bokeh-depth-of-field/](https://pixelmischiefblog.wordpress.com/2016/11/25/bokeh-depth-of-field/)
+* [https://www.adriancourreges.com/blog/2016/09/09/doom-2016-graphics-study/](https://www.adriancourreges.com/blog/2016/09/09/doom-2016-graphics-study/)
+
+## Import
+
+DepthOfFieldNode is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { dof } from 'three/addons/tsl/display/DepthOfFieldNode.js';
+```
+
+## Constructor
+
+### new DepthOfFieldNode( textureNode : TextureNode, viewZNode : Node., focusDistanceNode : Node., focalLengthNode : Node., bokehScaleNode : Node. )
+
+Constructs a new DOF node.
+
+**textureNode**
+
+The texture node that represents the input of the effect.
+
+**viewZNode**
+
+Represents the viewZ depth values of the scene.
+
+**focusDistanceNode**
+
+Defines the effect's focus which is the distance along the camera's look direction in world units.
+
+**focalLengthNode**
+
+How far an object can be from the focal plane before it goes completely out-of-focus in world units.
+
+**bokehScaleNode**
+
+A unitless value for artistic purposes to adjust the size of the bokeh.
+
+## Properties
+
+### .bokehScaleNode : Node.
+
+A unitless value for artistic purposes to adjust the size of the bokeh.
+
+### .focalLengthNode : Node.
+
+How far an object can be from the focal plane before it goes completely out-of-focus in world units.
+
+### .focusDistanceNode : Node.
+
+Defines the effect's focus which is the distance along the camera's look direction in world units.
+
+### .textureNode : TextureNode
+
+The texture node that represents the input of the effect.
+
+### .updateBeforeType : string
+
+The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node updates its internal uniforms once per frame in `updateBefore()`.
+
+Default is `'frame'`.
+
+**Overrides:** [TempNode#updateBeforeType](TempNode.html#updateBeforeType)
+
+### .viewZNode : Node.
+
+Represents the viewZ depth values of the scene.
+
+## Methods
+
+### .dispose()
+
+Frees internal resources. This method should be called when the effect is no longer required.
+
+**Overrides:** [TempNode#dispose](TempNode.html#dispose)
+
+### .getTextureNode() : PassTextureNode
+
+Returns the result of the effect as a texture node.
+
+**Returns:** A texture node that represents the result of the effect.
+
+### .setSize( width : number, height : number )
+
+Sets the size of the effect.
+
+**width**
+
+The width of the effect.
+
+**height**
+
+The height of the effect.
+
+### .setup( builder : NodeBuilder ) : ShaderCallNodeInternal
+
+This method is used to setup the effect's TSL code.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#setup](TempNode.html#setup)
+
+### .updateBefore( frame : NodeFrame )
+
+This method is used to update the effect's uniforms once per frame.
+
+**frame**
+
+The current node frame.
+
+**Overrides:** [TempNode#updateBefore](TempNode.html#updateBefore)
+
+## Source
+
+[examples/jsm/tsl/display/DepthOfFieldNode.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/tsl/display/DepthOfFieldNode.js)
\ No newline at end of file
diff --git a/docs/pages/DepthTexture.html.md b/docs/pages/DepthTexture.html.md
new file mode 100644
index 00000000000000..0dca0006257cd2
--- /dev/null
+++ b/docs/pages/DepthTexture.html.md
@@ -0,0 +1,111 @@
+*Inheritance: EventDispatcher → Texture →*
+
+# DepthTexture
+
+This class can be used to automatically save the depth information of a rendering into a texture.
+
+## Constructor
+
+### new DepthTexture( width : number, height : number, type : number, mapping : number, wrapS : number, wrapT : number, magFilter : number, minFilter : number, anisotropy : number, format : number, depth : number )
+
+Constructs a new depth texture.
+
+**width**
+
+The width of the texture.
+
+**height**
+
+The height of the texture.
+
+**type**
+
+The texture type.
+
+Default is `UnsignedIntType`.
+
+**mapping**
+
+The texture mapping.
+
+Default is `Texture.DEFAULT_MAPPING`.
+
+**wrapS**
+
+The wrapS value.
+
+Default is `ClampToEdgeWrapping`.
+
+**wrapT**
+
+The wrapT value.
+
+Default is `ClampToEdgeWrapping`.
+
+**magFilter**
+
+The mag filter value.
+
+Default is `LinearFilter`.
+
+**minFilter**
+
+The min filter value.
+
+Default is `LinearFilter`.
+
+**anisotropy**
+
+The anisotropy value.
+
+Default is `Texture.DEFAULT_ANISOTROPY`.
+
+**format**
+
+The texture format.
+
+Default is `DepthFormat`.
+
+**depth**
+
+The depth of the texture.
+
+Default is `1`.
+
+## Properties
+
+### .compareFunction : NeverCompare | LessCompare | EqualCompare | LessEqualCompare | GreaterCompare | NotEqualCompare | GreaterEqualCompare | AlwaysCompare
+
+Code corresponding to the depth compare function.
+
+Default is `null`.
+
+### .flipY : boolean
+
+If set to `true`, the texture is flipped along the vertical axis when uploaded to the GPU.
+
+Overwritten and set to `false` by default.
+
+Default is `false`.
+
+**Overrides:** [Texture#flipY](Texture.html#flipY)
+
+### .generateMipmaps : boolean
+
+Whether to generate mipmaps (if possible) for a texture.
+
+Overwritten and set to `false` by default.
+
+Default is `false`.
+
+**Overrides:** [Texture#generateMipmaps](Texture.html#generateMipmaps)
+
+### .isDepthTexture : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/textures/DepthTexture.js](https://github.com/mrdoob/three.js/blob/master/src/textures/DepthTexture.js)
\ No newline at end of file
diff --git a/docs/pages/DirectionalLight.html.md b/docs/pages/DirectionalLight.html.md
new file mode 100644
index 00000000000000..98bc6e0c13b08c
--- /dev/null
+++ b/docs/pages/DirectionalLight.html.md
@@ -0,0 +1,61 @@
+*Inheritance: EventDispatcher → Object3D → Light →*
+
+# DirectionalLight
+
+A light that gets emitted in a specific direction. This light will behave as though it is infinitely far away and the rays produced from it are all parallel. The common use case for this is to simulate daylight; the sun is far enough away that its position can be considered to be infinite, and all light rays coming from it are parallel.
+
+A common point of confusion for directional lights is that setting the rotation has no effect. This is because three.js's DirectionalLight is the equivalent to what is often called a 'Target Direct Light' in other applications.
+
+This means that its direction is calculated as pointing from the light's [Object3D#position](Object3D.html#position) to the [DirectionalLight#target](DirectionalLight.html#target) position (as opposed to a 'Free Direct Light' that just has a rotation component).
+
+This light can cast shadows - see the [DirectionalLightShadow](DirectionalLightShadow.html) for details.
+
+## Code Example
+
+```js
+// White directional light at half intensity shining from the top.
+const directionalLight = new THREE.DirectionalLight( 0xffffff, 0.5 );
+scene.add( directionalLight );
+```
+
+## Constructor
+
+### new DirectionalLight( color : number | Color | string, intensity : number )
+
+Constructs a new directional light.
+
+**color**
+
+The light's color.
+
+Default is `0xffffff`.
+
+**intensity**
+
+The light's strength/intensity.
+
+Default is `1`.
+
+## Properties
+
+### .isDirectionalLight : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .shadow : DirectionalLightShadow
+
+This property holds the light's shadow configuration.
+
+### .target : Object3D
+
+The directional light points from its position to the target's position.
+
+For the target's position to be changed to anything other than the default, it must be added to the scene.
+
+It is also possible to set the target to be another 3D object in the scene. The light will now track the target object.
+
+## Source
+
+[src/lights/DirectionalLight.js](https://github.com/mrdoob/three.js/blob/master/src/lights/DirectionalLight.js)
\ No newline at end of file
diff --git a/docs/pages/DirectionalLightHelper.html.md b/docs/pages/DirectionalLightHelper.html.md
new file mode 100644
index 00000000000000..4bfae85b54a831
--- /dev/null
+++ b/docs/pages/DirectionalLightHelper.html.md
@@ -0,0 +1,66 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# DirectionalLightHelper
+
+Helper object to assist with visualizing a [DirectionalLight](DirectionalLight.html)'s effect on the scene. This consists of plane and a line representing the light's position and direction.
+
+## Code Example
+
+```js
+const light = new THREE.DirectionalLight( 0xFFFFFF );
+scene.add( light );
+const helper = new THREE.DirectionalLightHelper( light, 5 );
+scene.add( helper );
+```
+
+## Constructor
+
+### new DirectionalLightHelper( light : DirectionalLight, size : number, color : number | Color | string )
+
+Constructs a new directional light helper.
+
+**light**
+
+The light to be visualized.
+
+**size**
+
+The dimensions of the plane.
+
+Default is `1`.
+
+**color**
+
+The helper's color. If not set, the helper will take the color of the light.
+
+## Properties
+
+### .color : number | Color | string
+
+The color parameter passed in the constructor. If not set, the helper will take the color of the light.
+
+### .light : DirectionalLight
+
+The light being visualized.
+
+### .lightPlane : Line
+
+Contains the line showing the location of the directional light.
+
+### .targetLine : Line
+
+Represents the target line of the directional light.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+### .update()
+
+Updates the helper to match the position and direction of the light being visualized.
+
+## Source
+
+[src/helpers/DirectionalLightHelper.js](https://github.com/mrdoob/three.js/blob/master/src/helpers/DirectionalLightHelper.js)
\ No newline at end of file
diff --git a/docs/pages/DirectionalLightNode.html.md b/docs/pages/DirectionalLightNode.html.md
new file mode 100644
index 00000000000000..820d8fcd272cbe
--- /dev/null
+++ b/docs/pages/DirectionalLightNode.html.md
@@ -0,0 +1,21 @@
+*Inheritance: EventDispatcher → Node → LightingNode → AnalyticLightNode →*
+
+# DirectionalLightNode
+
+Module for representing directional lights as nodes.
+
+## Constructor
+
+### new DirectionalLightNode( light : DirectionalLight )
+
+Constructs a new directional light node.
+
+**light**
+
+The directional light source.
+
+Default is `null`.
+
+## Source
+
+[src/nodes/lighting/DirectionalLightNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/lighting/DirectionalLightNode.js)
\ No newline at end of file
diff --git a/docs/pages/DirectionalLightShadow.html.md b/docs/pages/DirectionalLightShadow.html.md
new file mode 100644
index 00000000000000..0bea08788e7c39
--- /dev/null
+++ b/docs/pages/DirectionalLightShadow.html.md
@@ -0,0 +1,23 @@
+*Inheritance: LightShadow →*
+
+# DirectionalLightShadow
+
+Represents the shadow configuration of directional lights.
+
+## Constructor
+
+### new DirectionalLightShadow()
+
+Constructs a new directional light shadow.
+
+## Properties
+
+### .isDirectionalLightShadow : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/lights/DirectionalLightShadow.js](https://github.com/mrdoob/three.js/blob/master/src/lights/DirectionalLightShadow.js)
\ No newline at end of file
diff --git a/docs/pages/DiscreteInterpolant.html.md b/docs/pages/DiscreteInterpolant.html.md
new file mode 100644
index 00000000000000..e1a93fdf5c528a
--- /dev/null
+++ b/docs/pages/DiscreteInterpolant.html.md
@@ -0,0 +1,31 @@
+*Inheritance: Interpolant →*
+
+# DiscreteInterpolant
+
+Interpolant that evaluates to the sample value at the position preceding the parameter.
+
+## Constructor
+
+### new DiscreteInterpolant( parameterPositions : TypedArray, sampleValues : TypedArray, sampleSize : number, resultBuffer : TypedArray )
+
+Constructs a new discrete interpolant.
+
+**parameterPositions**
+
+The parameter positions hold the interpolation factors.
+
+**sampleValues**
+
+The sample values.
+
+**sampleSize**
+
+The sample size
+
+**resultBuffer**
+
+The result buffer.
+
+## Source
+
+[src/math/interpolants/DiscreteInterpolant.js](https://github.com/mrdoob/three.js/blob/master/src/math/interpolants/DiscreteInterpolant.js)
\ No newline at end of file
diff --git a/docs/pages/DodecahedronGeometry.html.md b/docs/pages/DodecahedronGeometry.html.md
new file mode 100644
index 00000000000000..8538648a7fbc37
--- /dev/null
+++ b/docs/pages/DodecahedronGeometry.html.md
@@ -0,0 +1,56 @@
+*Inheritance: EventDispatcher → BufferGeometry → PolyhedronGeometry →*
+
+# DodecahedronGeometry
+
+A geometry class for representing a dodecahedron.
+
+## Code Example
+
+```js
+const geometry = new THREE.DodecahedronGeometry();
+const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
+const dodecahedron = new THREE.Mesh( geometry, material );
+scene.add( dodecahedron );
+```
+
+## Constructor
+
+### new DodecahedronGeometry( radius : number, detail : number )
+
+Constructs a new dodecahedron geometry.
+
+**radius**
+
+Radius of the dodecahedron.
+
+Default is `1`.
+
+**detail**
+
+Setting this to a value greater than `0` adds vertices making it no longer a dodecahedron.
+
+Default is `0`.
+
+## Properties
+
+### .parameters : Object
+
+Holds the constructor parameters that have been used to generate the geometry. Any modification after instantiation does not change the geometry.
+
+**Overrides:** [PolyhedronGeometry#parameters](PolyhedronGeometry.html#parameters)
+
+## Static Methods
+
+### .fromJSON( data : Object ) : DodecahedronGeometry
+
+Factory method for creating an instance of this class from the given JSON object.
+
+**data**
+
+A JSON object representing the serialized geometry.
+
+**Returns:** A new instance.
+
+## Source
+
+[src/geometries/DodecahedronGeometry.js](https://github.com/mrdoob/three.js/blob/master/src/geometries/DodecahedronGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/DotScreenNode.html.md b/docs/pages/DotScreenNode.html.md
new file mode 100644
index 00000000000000..583e2cfa3542ce
--- /dev/null
+++ b/docs/pages/DotScreenNode.html.md
@@ -0,0 +1,65 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# DotScreenNode
+
+Post processing node for creating dot-screen effect.
+
+## Import
+
+DotScreenNode is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { dotScreen } from 'three/addons/tsl/display/DotScreenNode.js';
+```
+
+## Constructor
+
+### new DotScreenNode( inputNode : Node, angle : number, scale : number )
+
+Constructs a new dot screen node.
+
+**inputNode**
+
+The node that represents the input of the effect.
+
+**angle**
+
+The rotation of the effect in radians.
+
+Default is `1.57`.
+
+**scale**
+
+The scale of the effect. A higher value means smaller dots.
+
+Default is `1`.
+
+## Properties
+
+### .angle : UniformNode.
+
+A uniform node that represents the rotation of the effect in radians.
+
+### .inputNode : Node
+
+The node that represents the input of the effect.
+
+### .scale : UniformNode.
+
+A uniform node that represents the scale of the effect. A higher value means smaller dots.
+
+## Methods
+
+### .setup( builder : NodeBuilder ) : ShaderCallNodeInternal
+
+This method is used to setup the effect's TSL code.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#setup](TempNode.html#setup)
+
+## Source
+
+[examples/jsm/tsl/display/DotScreenNode.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/tsl/display/DotScreenNode.js)
\ No newline at end of file
diff --git a/docs/pages/DotScreenPass.html.md b/docs/pages/DotScreenPass.html.md
new file mode 100644
index 00000000000000..cb4cada546f273
--- /dev/null
+++ b/docs/pages/DotScreenPass.html.md
@@ -0,0 +1,92 @@
+*Inheritance: Pass →*
+
+# DotScreenPass
+
+Pass for creating a dot-screen effect.
+
+## Code Example
+
+```js
+const pass = new DotScreenPass( new THREE.Vector2( 0, 0 ), 0.5, 0.8 );
+composer.addPass( pass );
+```
+
+## Import
+
+DotScreenPass is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { DotScreenPass } from 'three/addons/postprocessing/DotScreenPass.js';
+```
+
+## Constructor
+
+### new DotScreenPass( center : Vector2, angle : number, scale : number )
+
+Constructs a new dot screen pass.
+
+**center**
+
+The center point.
+
+**angle**
+
+The rotation of the effect in radians.
+
+**scale**
+
+The scale of the effect. A higher value means smaller dots.
+
+## Properties
+
+### .material : ShaderMaterial
+
+The pass material.
+
+### .uniforms : Object
+
+The pass uniforms. Use this object if you want to update the `center`, `angle` or `scale` values at runtime.
+
+```js
+pass.uniforms.center.value.copy( center );
+pass.uniforms.angle.value = 0;
+pass.uniforms.scale.value = 0.5;
+```
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever the pass is no longer used in your app.
+
+**Overrides:** [Pass#dispose](Pass.html#dispose)
+
+### .render( renderer : WebGLRenderer, writeBuffer : WebGLRenderTarget, readBuffer : WebGLRenderTarget, deltaTime : number, maskActive : boolean )
+
+Performs the dot screen pass.
+
+**renderer**
+
+The renderer.
+
+**writeBuffer**
+
+The write buffer. This buffer is intended as the rendering destination for the pass.
+
+**readBuffer**
+
+The read buffer. The pass can access the result from the previous pass from this buffer.
+
+**deltaTime**
+
+The delta time in seconds.
+
+**maskActive**
+
+Whether masking is active or not.
+
+**Overrides:** [Pass#render](Pass.html#render)
+
+## Source
+
+[examples/jsm/postprocessing/DotScreenPass.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/DotScreenPass.js)
\ No newline at end of file
diff --git a/docs/pages/DragControls.html.md b/docs/pages/DragControls.html.md
new file mode 100644
index 00000000000000..2d47c112aa37d9
--- /dev/null
+++ b/docs/pages/DragControls.html.md
@@ -0,0 +1,112 @@
+*Inheritance: EventDispatcher → Controls →*
+
+# DragControls
+
+This class can be used to provide a drag'n'drop interaction.
+
+## Code Example
+
+```js
+const controls = new DragControls( objects, camera, renderer.domElement );
+// add event listener to highlight dragged objects
+controls.addEventListener( 'dragstart', function ( event ) {
+ event.object.material.emissive.set( 0xaaaaaa );
+} );
+controls.addEventListener( 'dragend', function ( event ) {
+ event.object.material.emissive.set( 0x000000 );
+} );
+```
+
+## Import
+
+DragControls is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { DragControls } from 'three/addons/controls/DragControls.js';
+```
+
+## Constructor
+
+### new DragControls( objects : Array., camera : Camera, domElement : HTMLElement )
+
+Constructs a new controls instance.
+
+**objects**
+
+An array of draggable 3D objects.
+
+**camera**
+
+The camera of the rendered scene.
+
+**domElement**
+
+The HTML DOM element used for event listeners.
+
+Default is `null`.
+
+## Properties
+
+### .objects : Array.
+
+An array of draggable 3D objects.
+
+### .raycaster : Raycaster
+
+The raycaster used for detecting 3D objects.
+
+### .recursive : boolean
+
+Whether children of draggable objects can be dragged independently from their parent.
+
+Default is `true`.
+
+### .rotateSpeed : number
+
+The speed at which the object will rotate when dragged in `rotate` mode. The higher the number the faster the rotation.
+
+Default is `1`.
+
+### .transformGroup : boolean
+
+This option only works if the `objects` array contains a single draggable group object. If set to `true`, the controls does not transform individual objects but the entire group.
+
+Default is `false`.
+
+## Events
+
+### .drag
+
+Fires when the user drags a 3D object.
+
+##### Type:
+
+* Object
+
+### .dragend
+
+Fires when the user has finished dragging a 3D object.
+
+##### Type:
+
+* Object
+
+### .hoveroff
+
+Fires when the pointer is moved out of a 3D object.
+
+##### Type:
+
+* Object
+
+### .hoveron
+
+Fires when the pointer is moved onto a 3D object, or onto one of its children.
+
+##### Type:
+
+* Object
+
+## Source
+
+[examples/jsm/controls/DragControls.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/controls/DragControls.js)
\ No newline at end of file
diff --git a/docs/pages/EXRExporter.html.md b/docs/pages/EXRExporter.html.md
new file mode 100644
index 00000000000000..1023d55fc93ecd
--- /dev/null
+++ b/docs/pages/EXRExporter.html.md
@@ -0,0 +1,71 @@
+# EXRExporter
+
+An exporter for EXR.
+
+EXR ( Extended Dynamic Range) is an [open format specification](https://github.com/AcademySoftwareFoundation/openexr) for professional-grade image storage format of the motion picture industry. The purpose of format is to accurately and efficiently represent high-dynamic-range scene-linear image data and associated metadata. The library is widely used in host application software where accuracy is critical, such as photorealistic rendering, texture access, image compositing, deep compositing, and DI.
+
+## Code Example
+
+```js
+const exporter = new EXRExporter();
+const result = await exporter.parse( renderer, options );
+```
+
+## Import
+
+EXRExporter is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { EXRExporter } from 'three/addons/exporters/EXRExporter.js';
+```
+
+## Constructor
+
+### new EXRExporter()
+
+## Methods
+
+### .parse( arg1 : DataTexture | WebGPURenderer | WebGLRenderer, arg2 : EXRExporter~Options | RenderTarget, arg3 : EXRExporter~Options ) : Promise. (async)
+
+This method has two variants.
+
+* When exporting a data texture, it receives two parameters. The texture and the exporter options.
+* When exporting a render target (e.g. a PMREM), it receives three parameters. The renderer, the render target and the exporter options.
+
+**arg1**
+
+The data texture to export or a renderer.
+
+**arg2**
+
+The exporter options or a render target.
+
+**arg3**
+
+The exporter options.
+
+**Returns:** A Promise that resolves with the exported EXR.
+
+## Type Definitions
+
+### .Options
+
+Export options of `EXRExporter`.
+
+**type**
+[HalfFloatType](global.html#HalfFloatType) | [FloatType](global.html#FloatType)
+
+Output data type.
+
+Default is `HalfFloatType`.
+
+**type**
+NO\_COMPRESSION | ZIP\_COMPRESSION | ZIPS\_COMPRESSION
+
+The compression algorithm.
+
+Default is `ZIP_COMPRESSION`.
+
+## Source
+
+[examples/jsm/exporters/EXRExporter.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/exporters/EXRExporter.js)
\ No newline at end of file
diff --git a/docs/pages/EXRLoader.html.md b/docs/pages/EXRLoader.html.md
new file mode 100644
index 00000000000000..7cc7f36ff30c01
--- /dev/null
+++ b/docs/pages/EXRLoader.html.md
@@ -0,0 +1,84 @@
+*Inheritance: Loader → DataTextureLoader →*
+
+# EXRLoader
+
+A loader for the OpenEXR texture format.
+
+`EXRLoader` currently supports uncompressed, ZIP(S), RLE, PIZ and DWA/B compression. Supports reading as UnsignedByte, HalfFloat and Float type data texture.
+
+## Code Example
+
+```js
+const loader = new EXRLoader();
+const texture = await loader.loadAsync( 'textures/memorial.exr' );
+```
+
+## Import
+
+EXRLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { EXRLoader } from 'three/addons/loaders/EXRLoader.js';
+```
+
+## Constructor
+
+### new EXRLoader( manager : LoadingManager )
+
+Constructs a new EXR loader.
+
+**manager**
+
+The loading manager.
+
+## Properties
+
+### .outputFormat : RGBAFormat | RGFormat | RedFormat
+
+Texture output format.
+
+Default is `RGBAFormat`.
+
+### .type : HalfFloatType | FloatType
+
+The texture type.
+
+Default is `HalfFloatType`.
+
+## Methods
+
+### .parse( buffer : ArrayBuffer ) : DataTextureLoader~TexData
+
+Parses the given EXR texture data.
+
+**buffer**
+
+The raw texture data.
+
+**Overrides:** [DataTextureLoader#parse](DataTextureLoader.html#parse)
+
+**Returns:** An object representing the parsed texture data.
+
+### .setDataType( value : HalfFloatType | FloatType ) : EXRLoader
+
+Sets the texture type.
+
+**value**
+
+The texture type to set.
+
+**Returns:** A reference to this loader.
+
+### .setOutputFormat( value : RGBAFormat | RGFormat | RedFormat ) : EXRLoader
+
+Sets texture output format. Defaults to `RGBAFormat`.
+
+**value**
+
+Texture output format.
+
+**Returns:** A reference to this loader.
+
+## Source
+
+[examples/jsm/loaders/EXRLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/EXRLoader.js)
\ No newline at end of file
diff --git a/docs/pages/Earcut.html.md b/docs/pages/Earcut.html.md
new file mode 100644
index 00000000000000..e159a7c7b4acb6
--- /dev/null
+++ b/docs/pages/Earcut.html.md
@@ -0,0 +1,37 @@
+# Earcut
+
+An implementation of the earcut polygon triangulation algorithm. The code is a port of [mapbox/earcut](https://github.com/mapbox/earcut).
+
+## Constructor
+
+### new Earcut()
+
+See:
+
+* [https://github.com/mapbox/earcut](https://github.com/mapbox/earcut)
+
+## Static Methods
+
+### .triangulate( data : Array., holeIndices : Array., dim : number ) : Array.
+
+Triangulates the given shape definition by returning an array of triangles.
+
+**data**
+
+An array with 2D points.
+
+**holeIndices**
+
+An array with indices defining holes.
+
+**dim**
+
+The number of coordinates per vertex in the input array.
+
+Default is `2`.
+
+**Returns:** An array representing the triangulated faces. Each face is defined by three consecutive numbers representing vertex indices.
+
+## Source
+
+[src/extras/Earcut.js](https://github.com/mrdoob/three.js/blob/master/src/extras/Earcut.js)
\ No newline at end of file
diff --git a/docs/pages/EdgeSplitModifier.html.md b/docs/pages/EdgeSplitModifier.html.md
new file mode 100644
index 00000000000000..19c9625ea94654
--- /dev/null
+++ b/docs/pages/EdgeSplitModifier.html.md
@@ -0,0 +1,48 @@
+# EdgeSplitModifier
+
+The modifier can be used to split faces at sharp edges. This allows to compute normals without smoothing the edges which can lead to an improved visual result.
+
+## Code Example
+
+```js
+const modifier = new EdgeSplitModifier();
+geometry = modifier.modify( geometry, Math.PI * 0.4 );
+```
+
+## Import
+
+EdgeSplitModifier is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { EdgeSplitModifier } from 'three/addons/modifiers/EdgeSplitModifier.js';
+```
+
+## Constructor
+
+### new EdgeSplitModifier()
+
+## Methods
+
+### .modify( geometry : BufferGeometry, cutOffAngle : number, tryKeepNormals : boolean ) : BufferGeometry
+
+Returns a new, modified version of the given geometry by applying an edge-split operation. Please note that the resulting geometry is always indexed.
+
+**geometry**
+
+The geometry to modify.
+
+**cutOffAngle**
+
+The cut off angle in radians.
+
+**tryKeepNormals**
+
+Whether to try to keep normals or not.
+
+Default is `true`.
+
+**Returns:** A new, modified geometry.
+
+## Source
+
+[examples/jsm/modifiers/EdgeSplitModifier.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/modifiers/EdgeSplitModifier.js)
\ No newline at end of file
diff --git a/docs/pages/EdgesGeometry.html.md b/docs/pages/EdgesGeometry.html.md
new file mode 100644
index 00000000000000..2693e2cd73e410
--- /dev/null
+++ b/docs/pages/EdgesGeometry.html.md
@@ -0,0 +1,44 @@
+*Inheritance: EventDispatcher → BufferGeometry →*
+
+# EdgesGeometry
+
+Can be used as a helper object to view the edges of a geometry.
+
+Note: It is not yet possible to serialize/deserialize instances of this class.
+
+## Code Example
+
+```js
+const geometry = new THREE.BoxGeometry();
+const edges = new THREE.EdgesGeometry( geometry );
+const line = new THREE.LineSegments( edges );
+scene.add( line );
+```
+
+## Constructor
+
+### new EdgesGeometry( geometry : BufferGeometry, thresholdAngle : number )
+
+Constructs a new edges geometry.
+
+**geometry**
+
+The geometry.
+
+Default is `null`.
+
+**thresholdAngle**
+
+An edge is only rendered if the angle (in degrees) between the face normals of the adjoining faces exceeds this value.
+
+Default is `1`.
+
+## Properties
+
+### .parameters : Object
+
+Holds the constructor parameters that have been used to generate the geometry. Any modification after instantiation does not change the geometry.
+
+## Source
+
+[src/geometries/EdgesGeometry.js](https://github.com/mrdoob/three.js/blob/master/src/geometries/EdgesGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/EffectComposer.html.md b/docs/pages/EffectComposer.html.md
new file mode 100644
index 00000000000000..a7add40144949f
--- /dev/null
+++ b/docs/pages/EffectComposer.html.md
@@ -0,0 +1,155 @@
+# EffectComposer
+
+Used to implement post-processing effects in three.js. The class manages a chain of post-processing passes to produce the final visual result. Post-processing passes are executed in order of their addition/insertion. The last pass is automatically rendered to screen.
+
+This module can only be used with [WebGLRenderer](WebGLRenderer.html).
+
+## Code Example
+
+```js
+const composer = new EffectComposer( renderer );
+// adding some passes
+const renderPass = new RenderPass( scene, camera );
+composer.addPass( renderPass );
+const glitchPass = new GlitchPass();
+composer.addPass( glitchPass );
+const outputPass = new OutputPass()
+composer.addPass( outputPass );
+function animate() {
+ composer.render(); // instead of renderer.render()
+}
+```
+
+## Import
+
+EffectComposer is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js';
+```
+
+## Constructor
+
+### new EffectComposer( renderer : WebGLRenderer, renderTarget : WebGLRenderTarget )
+
+Constructs a new effect composer.
+
+**renderer**
+
+The renderer.
+
+**renderTarget**
+
+This render target and a clone will be used as the internal read and write buffers. If not given, the composer creates the buffers automatically.
+
+## Properties
+
+### .passes : Array.
+
+An array representing the (ordered) chain of post-processing passes.
+
+### .readBuffer : WebGLRenderTarget
+
+A reference to the internal read buffer. Passes usually read the previous render result from this buffer.
+
+### .renderToScreen : boolean
+
+Whether the final pass is rendered to the screen (default framebuffer) or not.
+
+Default is `true`.
+
+### .renderer : WebGLRenderer
+
+The renderer.
+
+### .writeBuffer : WebGLRenderTarget
+
+A reference to the internal write buffer. Passes usually write their result into this buffer.
+
+## Methods
+
+### .addPass( pass : Pass )
+
+Adds the given pass to the pass chain.
+
+**pass**
+
+The pass to add.
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever the composer is no longer used in your app.
+
+### .insertPass( pass : Pass, index : number )
+
+Inserts the given pass at a given index.
+
+**pass**
+
+The pass to insert.
+
+**index**
+
+The index into the pass chain.
+
+### .isLastEnabledPass( passIndex : number ) : boolean
+
+Returns `true` if the pass for the given index is the last enabled pass in the pass chain.
+
+**passIndex**
+
+The pass index.
+
+**Returns:** Whether the pass for the given index is the last pass in the pass chain.
+
+### .removePass( pass : Pass )
+
+Removes the given pass from the pass chain.
+
+**pass**
+
+The pass to remove.
+
+### .render( deltaTime : number )
+
+Executes all enabled post-processing passes in order to produce the final frame.
+
+**deltaTime**
+
+The delta time in seconds. If not given, the composer computes its own time delta value.
+
+### .reset( renderTarget : WebGLRenderTarget )
+
+Resets the internal state of the EffectComposer.
+
+**renderTarget**
+
+This render target has the same purpose like the one from the constructor. If set, it is used to setup the read and write buffers.
+
+### .setPixelRatio( pixelRatio : number )
+
+Sets device pixel ratio. This is usually used for HiDPI device to prevent blurring output. Setting the pixel ratio will automatically resize the composer.
+
+**pixelRatio**
+
+The pixel ratio to set.
+
+### .setSize( width : number, height : number )
+
+Resizes the internal read and write buffers as well as all passes. Similar to [WebGLRenderer#setSize](WebGLRenderer.html#setSize), this method honors the current pixel ration.
+
+**width**
+
+The width in logical pixels.
+
+**height**
+
+The height in logical pixels.
+
+### .swapBuffers()
+
+Swaps the internal read/write buffers.
+
+## Source
+
+[examples/jsm/postprocessing/EffectComposer.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/EffectComposer.js)
\ No newline at end of file
diff --git a/docs/pages/EllipseCurve.html.md b/docs/pages/EllipseCurve.html.md
new file mode 100644
index 00000000000000..fa2f2697b47e4f
--- /dev/null
+++ b/docs/pages/EllipseCurve.html.md
@@ -0,0 +1,154 @@
+*Inheritance: Curve →*
+
+# EllipseCurve
+
+A curve representing an ellipse.
+
+## Code Example
+
+```js
+const curve = new THREE.EllipseCurve(
+ 0, 0,
+ 10, 10,
+ 0, 2 * Math.PI,
+ false,
+ 0
+);
+const points = curve.getPoints( 50 );
+const geometry = new THREE.BufferGeometry().setFromPoints( points );
+const material = new THREE.LineBasicMaterial( { color: 0xff0000 } );
+// Create the final object to add to the scene
+const ellipse = new THREE.Line( geometry, material );
+```
+
+## Constructor
+
+### new EllipseCurve( aX : number, aY : number, xRadius : number, yRadius : number, aStartAngle : number, aEndAngle : number, aClockwise : boolean, aRotation : number )
+
+Constructs a new ellipse curve.
+
+**aX**
+
+The X center of the ellipse.
+
+Default is `0`.
+
+**aY**
+
+The Y center of the ellipse.
+
+Default is `0`.
+
+**xRadius**
+
+The radius of the ellipse in the x direction.
+
+Default is `1`.
+
+**yRadius**
+
+The radius of the ellipse in the y direction.
+
+Default is `1`.
+
+**aStartAngle**
+
+The start angle of the curve in radians starting from the positive X axis.
+
+Default is `0`.
+
+**aEndAngle**
+
+The end angle of the curve in radians starting from the positive X axis.
+
+Default is `Math.PI*2`.
+
+**aClockwise**
+
+Whether the ellipse is drawn clockwise or not.
+
+Default is `false`.
+
+**aRotation**
+
+The rotation angle of the ellipse in radians, counterclockwise from the positive X axis.
+
+Default is `0`.
+
+## Properties
+
+### .aClockwise : boolean
+
+Whether the ellipse is drawn clockwise or not.
+
+Default is `false`.
+
+### .aEndAngle : number
+
+The end angle of the curve in radians starting from the positive X axis.
+
+Default is `Math.PI*2`.
+
+### .aRotation : number
+
+The rotation angle of the ellipse in radians, counterclockwise from the positive X axis.
+
+Default is `0`.
+
+### .aStartAngle : number
+
+The start angle of the curve in radians starting from the positive X axis.
+
+Default is `0`.
+
+### .aX : number
+
+The X center of the ellipse.
+
+Default is `0`.
+
+### .aY : number
+
+The Y center of the ellipse.
+
+Default is `0`.
+
+### .isEllipseCurve : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .xRadius : number
+
+The radius of the ellipse in the x direction. Setting the this value equal to the [EllipseCurve#yRadius](EllipseCurve.html#yRadius) will result in a circle.
+
+Default is `1`.
+
+### .yRadius : number
+
+The radius of the ellipse in the y direction. Setting the this value equal to the [EllipseCurve#xRadius](EllipseCurve.html#xRadius) will result in a circle.
+
+Default is `1`.
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector2 ) : Vector2
+
+Returns a point on the curve.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve.
+
+## Source
+
+[src/extras/curves/EllipseCurve.js](https://github.com/mrdoob/three.js/blob/master/src/extras/curves/EllipseCurve.js)
\ No newline at end of file
diff --git a/docs/pages/EnvironmentNode.html.md b/docs/pages/EnvironmentNode.html.md
new file mode 100644
index 00000000000000..99f0f087113250
--- /dev/null
+++ b/docs/pages/EnvironmentNode.html.md
@@ -0,0 +1,29 @@
+*Inheritance: EventDispatcher → Node → LightingNode →*
+
+# EnvironmentNode
+
+Represents a physical model for Image-based lighting (IBL). The environment is defined via environment maps in the equirectangular, cube map or cubeUV (PMREM) format. `EnvironmentNode` is intended for PBR materials like [MeshStandardNodeMaterial](MeshStandardNodeMaterial.html).
+
+## Constructor
+
+### new EnvironmentNode( envNode : Node )
+
+Constructs a new environment node.
+
+**envNode**
+
+A node representing the environment.
+
+Default is `null`.
+
+## Properties
+
+### .envNode : Node
+
+A node representing the environment.
+
+Default is `null`.
+
+## Source
+
+[src/nodes/lighting/EnvironmentNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/lighting/EnvironmentNode.js)
\ No newline at end of file
diff --git a/docs/pages/Euler.html.md b/docs/pages/Euler.html.md
new file mode 100644
index 00000000000000..18e48935bfd855
--- /dev/null
+++ b/docs/pages/Euler.html.md
@@ -0,0 +1,231 @@
+# Euler
+
+A class representing Euler angles.
+
+Euler angles describe a rotational transformation by rotating an object on its various axes in specified amounts per axis, and a specified axis order.
+
+Iterating through an instance will yield its components (x, y, z, order) in the corresponding order.
+
+## Code Example
+
+```js
+const a = new THREE.Euler( 0, 1, 1.57, 'XYZ' );
+const b = new THREE.Vector3( 1, 0, 1 );
+b.applyEuler(a);
+```
+
+## Constructor
+
+### new Euler( x : number, y : number, z : number, order : string )
+
+Constructs a new euler instance.
+
+**x**
+
+The angle of the x axis in radians.
+
+Default is `0`.
+
+**y**
+
+The angle of the y axis in radians.
+
+Default is `0`.
+
+**z**
+
+The angle of the z axis in radians.
+
+Default is `0`.
+
+**order**
+
+A string representing the order that the rotations are applied.
+
+Default is `Euler.DEFAULT_ORDER`.
+
+## Properties
+
+### .isEuler : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .order : string
+
+A string representing the order that the rotations are applied.
+
+Default is `'XYZ'`.
+
+### .x : number
+
+The angle of the x axis in radians.
+
+Default is `0`.
+
+### .y : number
+
+The angle of the y axis in radians.
+
+Default is `0`.
+
+### .z : number
+
+The angle of the z axis in radians.
+
+Default is `0`.
+
+### .DEFAULT_ORDER : string
+
+The default Euler angle order.
+
+Default is `'XYZ'`.
+
+## Methods
+
+### .clone() : Euler
+
+Returns a new Euler instance with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .copy( euler : Euler ) : Euler
+
+Copies the values of the given Euler instance to this instance.
+
+**euler**
+
+The Euler instance to copy.
+
+**Returns:** A reference to this Euler instance.
+
+### .equals( euler : Euler ) : boolean
+
+Returns `true` if this Euler instance is equal with the given one.
+
+**euler**
+
+The Euler instance to test for equality.
+
+**Returns:** Whether this Euler instance is equal with the given one.
+
+### .fromArray( array : Array. ) : Euler
+
+Sets this Euler instance's components to values from the given array. The first three entries of the array are assign to the x,y and z components. An optional fourth entry defines the Euler order.
+
+**array**
+
+An array holding the Euler component values.
+
+**Returns:** A reference to this Euler instance.
+
+### .reorder( newOrder : string ) : Euler
+
+Resets the euler angle with a new order by creating a quaternion from this euler angle and then setting this euler angle with the quaternion and the new order.
+
+Warning: This discards revolution information.
+
+**newOrder**
+
+A string representing the new order that the rotations are applied.
+
+**Returns:** A reference to this Euler instance.
+
+### .set( x : number, y : number, z : number, order : string ) : Euler
+
+Sets the Euler components.
+
+**x**
+
+The angle of the x axis in radians.
+
+**y**
+
+The angle of the y axis in radians.
+
+**z**
+
+The angle of the z axis in radians.
+
+**order**
+
+A string representing the order that the rotations are applied.
+
+**Returns:** A reference to this Euler instance.
+
+### .setFromQuaternion( q : Quaternion, order : string, update : boolean ) : Euler
+
+Sets the angles of this Euler instance from a normalized quaternion.
+
+**q**
+
+A normalized Quaternion.
+
+**order**
+
+A string representing the order that the rotations are applied.
+
+**update**
+
+Whether the internal `onChange` callback should be executed or not.
+
+Default is `true`.
+
+**Returns:** A reference to this Euler instance.
+
+### .setFromRotationMatrix( m : Matrix4, order : string, update : boolean ) : Euler
+
+Sets the angles of this Euler instance from a pure rotation matrix.
+
+**m**
+
+A 4x4 matrix of which the upper 3x3 of matrix is a pure rotation matrix (i.e. unscaled).
+
+**order**
+
+A string representing the order that the rotations are applied.
+
+**update**
+
+Whether the internal `onChange` callback should be executed or not.
+
+Default is `true`.
+
+**Returns:** A reference to this Euler instance.
+
+### .setFromVector3( v : Vector3, order : string ) : Euler
+
+Sets the angles of this Euler instance from the given vector.
+
+**v**
+
+The vector.
+
+**order**
+
+A string representing the order that the rotations are applied.
+
+**Returns:** A reference to this Euler instance.
+
+### .toArray( array : Array., offset : number ) : Array.
+
+Writes the components of this Euler instance to the given array. If no array is provided, the method returns a new instance.
+
+**array**
+
+The target array holding the Euler components.
+
+Default is `[]`.
+
+**offset**
+
+Index of the first element in the array.
+
+Default is `0`.
+
+**Returns:** The Euler components.
+
+## Source
+
+[src/math/Euler.js](https://github.com/mrdoob/three.js/blob/master/src/math/Euler.js)
\ No newline at end of file
diff --git a/docs/pages/EventDispatcher.html.md b/docs/pages/EventDispatcher.html.md
new file mode 100644
index 00000000000000..9633696a3fdc38
--- /dev/null
+++ b/docs/pages/EventDispatcher.html.md
@@ -0,0 +1,79 @@
+# EventDispatcher
+
+This modules allows to dispatch event objects on custom JavaScript objects.
+
+Main repository: [eventdispatcher.js](https://github.com/mrdoob/eventdispatcher.js/)
+
+Code Example:
+
+## Code Example
+
+```js
+class Car extends EventDispatcher {
+ start() {
+ this.dispatchEvent( { type: 'start', message: 'vroom vroom!' } );
+ }
+};
+// Using events with the custom object
+const car = new Car();
+car.addEventListener( 'start', function ( event ) {
+ alert( event.message );
+} );
+car.start();
+```
+
+## Constructor
+
+### new EventDispatcher()
+
+## Methods
+
+### .addEventListener( type : string, listener : function )
+
+Adds the given event listener to the given event type.
+
+**type**
+
+The type of event to listen to.
+
+**listener**
+
+The function that gets called when the event is fired.
+
+### .dispatchEvent( event : Object )
+
+Dispatches an event object.
+
+**event**
+
+The event that gets fired.
+
+### .hasEventListener( type : string, listener : function ) : boolean
+
+Returns `true` if the given event listener has been added to the given event type.
+
+**type**
+
+The type of event.
+
+**listener**
+
+The listener to check.
+
+**Returns:** Whether the given event listener has been added to the given event type.
+
+### .removeEventListener( type : string, listener : function )
+
+Removes the given event listener from the given event type.
+
+**type**
+
+The type of event.
+
+**listener**
+
+The listener to remove.
+
+## Source
+
+[src/core/EventDispatcher.js](https://github.com/mrdoob/three.js/blob/master/src/core/EventDispatcher.js)
\ No newline at end of file
diff --git a/docs/pages/EventNode.html.md b/docs/pages/EventNode.html.md
new file mode 100644
index 00000000000000..cbe893cbeb79c3
--- /dev/null
+++ b/docs/pages/EventNode.html.md
@@ -0,0 +1,23 @@
+*Inheritance: EventDispatcher → Node →*
+
+# EventNode
+
+EventNode is a node that executes a callback during specific update phases.
+
+## Constructor
+
+### new EventNode( eventType : string, callback : function )
+
+Creates an EventNode.
+
+**eventType**
+
+The type of event
+
+**callback**
+
+The callback to execute on update.
+
+## Source
+
+[src/nodes/utils/EventNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/utils/EventNode.js)
\ No newline at end of file
diff --git a/docs/pages/ExpressionNode.html.md b/docs/pages/ExpressionNode.html.md
new file mode 100644
index 00000000000000..fd9f2a43eab823
--- /dev/null
+++ b/docs/pages/ExpressionNode.html.md
@@ -0,0 +1,35 @@
+*Inheritance: EventDispatcher → Node →*
+
+# ExpressionNode
+
+This class can be used to implement basic expressions in shader code. Basic examples for that are `return`, `continue` or `discard` statements.
+
+## Constructor
+
+### new ExpressionNode( snippet : string, nodeType : string )
+
+Constructs a new expression node.
+
+**snippet**
+
+The native code snippet.
+
+Default is `''`.
+
+**nodeType**
+
+The node type.
+
+Default is `'void'`.
+
+## Properties
+
+### .snippet : string
+
+The native code snippet.
+
+Default is `''`.
+
+## Source
+
+[src/nodes/code/ExpressionNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/code/ExpressionNode.js)
\ No newline at end of file
diff --git a/docs/pages/ExternalTexture.html.md b/docs/pages/ExternalTexture.html.md
new file mode 100644
index 00000000000000..f21c493278e5ac
--- /dev/null
+++ b/docs/pages/ExternalTexture.html.md
@@ -0,0 +1,39 @@
+*Inheritance: EventDispatcher → Texture →*
+
+# ExternalTexture
+
+Represents a texture created externally with the same renderer context.
+
+This may be a texture from a protected media stream, device camera feed, or other data feeds like a depth sensor.
+
+Note that this class is only supported in [WebGLRenderer](WebGLRenderer.html), and in the [WebGPURenderer](WebGPURenderer.html) WebGPU backend.
+
+## Constructor
+
+### new ExternalTexture( sourceTexture : WebGLTexture | GPUTexture )
+
+Creates a new raw texture.
+
+**sourceTexture**
+
+The external texture.
+
+Default is `null`.
+
+## Properties
+
+### .isExternalTexture : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .sourceTexture : WebGLTexture | GPUTexture
+
+The external source texture.
+
+Default is `null`.
+
+## Source
+
+[src/textures/ExternalTexture.js](https://github.com/mrdoob/three.js/blob/master/src/textures/ExternalTexture.js)
\ No newline at end of file
diff --git a/docs/pages/ExtrudeGeometry.html.md b/docs/pages/ExtrudeGeometry.html.md
new file mode 100644
index 00000000000000..68e77b9df38653
--- /dev/null
+++ b/docs/pages/ExtrudeGeometry.html.md
@@ -0,0 +1,135 @@
+*Inheritance: EventDispatcher → BufferGeometry →*
+
+# ExtrudeGeometry
+
+Creates extruded geometry from a path shape.
+
+## Code Example
+
+```js
+const length = 12, width = 8;
+const shape = new THREE.Shape();
+shape.moveTo( 0,0 );
+shape.lineTo( 0, width );
+shape.lineTo( length, width );
+shape.lineTo( length, 0 );
+shape.lineTo( 0, 0 );
+const geometry = new THREE.ExtrudeGeometry( shape );
+const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
+const mesh = new THREE.Mesh( geometry, material ) ;
+scene.add( mesh );
+```
+
+## Constructor
+
+### new ExtrudeGeometry( shapes : Shape | Array., options : ExtrudeGeometry~Options )
+
+Constructs a new extrude geometry.
+
+**shapes**
+
+A shape or an array of shapes.
+
+**options**
+
+The extrude settings.
+
+## Properties
+
+### .parameters : Object
+
+Holds the constructor parameters that have been used to generate the geometry. Any modification after instantiation does not change the geometry.
+
+## Static Methods
+
+### .fromJSON( data : Object, shapes : Array. ) : ExtrudeGeometry
+
+Factory method for creating an instance of this class from the given JSON object.
+
+**data**
+
+A JSON object representing the serialized geometry.
+
+**shapes**
+
+An array of shapes.
+
+**Returns:** A new instance.
+
+## Type Definitions
+
+### .Options
+
+Represents the `options` type of the geometry's constructor.
+
+**curveSegments**
+number
+
+Number of points on the curves.
+
+Default is `12`.
+
+**steps**
+number
+
+Number of points used for subdividing segments along the depth of the extruded spline.
+
+Default is `1`.
+
+**depth**
+number
+
+Depth to extrude the shape.
+
+Default is `1`.
+
+**bevelEnabled**
+boolean
+
+Whether to beveling to the shape or not.
+
+Default is `true`.
+
+**bevelThickness**
+number
+
+How deep into the original shape the bevel goes.
+
+Default is `0.2`.
+
+**bevelSize**
+number
+
+Distance from the shape outline that the bevel extends.
+
+Default is `bevelThickness-0.1`.
+
+**bevelOffset**
+number
+
+Distance from the shape outline that the bevel starts.
+
+Default is `0`.
+
+**bevelSegments**
+number
+
+Number of bevel layers.
+
+Default is `3`.
+
+**extrudePath**
+[Curve](Curve.html)
+
+A 3D spline path along which the shape should be extruded. Bevels not supported for path extrusion.
+
+Default is `null`.
+
+**UVGenerator**
+Object
+
+An object that provides UV generator functions for custom UV generation.
+
+## Source
+
+[src/geometries/ExtrudeGeometry.js](https://github.com/mrdoob/three.js/blob/master/src/geometries/ExtrudeGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/FBXLoader.html.md b/docs/pages/FBXLoader.html.md
new file mode 100644
index 00000000000000..754d0859b16cc6
--- /dev/null
+++ b/docs/pages/FBXLoader.html.md
@@ -0,0 +1,89 @@
+*Inheritance: Loader →*
+
+# FBXLoader
+
+A loader for the FBX format.
+
+Requires FBX file to be >= 7.0 and in ASCII or >= 6400 in Binary format. Versions lower than this may load but will probably have errors.
+
+Needs Support:
+
+* Morph normals / blend shape normals
+
+FBX format references:
+
+* [C++ SDK reference](https://help.autodesk.com/view/FBX/2017/ENU/?guid=__cpp_ref_index_html)
+
+Binary format specification:
+
+* [FBX binary file format specification](https://code.blender.org/2013/08/fbx-binary-file-format-specification/)
+
+## Code Example
+
+```js
+const loader = new FBXLoader();
+const object = await loader.loadAsync( 'models/fbx/stanford-bunny.fbx' );
+scene.add( object );
+```
+
+## Import
+
+FBXLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { FBXLoader } from 'three/addons/loaders/FBXLoader.js';
+```
+
+## Constructor
+
+### new FBXLoader( manager : LoadingManager )
+
+Constructs a new FBX loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded FBX asset to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( FBXBuffer : ArrayBuffer, path : string ) : Group
+
+Parses the given FBX data and returns the resulting group.
+
+**FBXBuffer**
+
+The raw FBX data as an array buffer.
+
+**path**
+
+The URL base path.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** An object representing the parsed asset.
+
+## Source
+
+[examples/jsm/loaders/FBXLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/FBXLoader.js)
\ No newline at end of file
diff --git a/docs/pages/FXAANode.html.md b/docs/pages/FXAANode.html.md
new file mode 100644
index 00000000000000..fca67b44361c68
--- /dev/null
+++ b/docs/pages/FXAANode.html.md
@@ -0,0 +1,63 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# FXAANode
+
+Post processing node for applying FXAA. This node requires sRGB input so tone mapping and color space conversion must happen before the anti-aliasing.
+
+## Import
+
+FXAANode is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { fxaa } from 'three/addons/tsl/display/FXAANode.js';
+```
+
+## Constructor
+
+### new FXAANode( textureNode : TextureNode )
+
+Constructs a new FXAA node.
+
+**textureNode**
+
+The texture node that represents the input of the effect.
+
+## Properties
+
+### .textureNode : TextureNode
+
+The texture node that represents the input of the effect.
+
+### .updateBeforeType : string
+
+The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node updates its internal uniforms once per frame in `updateBefore()`.
+
+Default is `'frame'`.
+
+**Overrides:** [TempNode#updateBeforeType](TempNode.html#updateBeforeType)
+
+## Methods
+
+### .setup( builder : NodeBuilder ) : ShaderCallNodeInternal
+
+This method is used to setup the effect's TSL code.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#setup](TempNode.html#setup)
+
+### .updateBefore( frame : NodeFrame )
+
+This method is used to update the effect's uniforms once per frame.
+
+**frame**
+
+The current node frame.
+
+**Overrides:** [TempNode#updateBefore](TempNode.html#updateBefore)
+
+## Source
+
+[examples/jsm/tsl/display/FXAANode.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/tsl/display/FXAANode.js)
\ No newline at end of file
diff --git a/docs/pages/FXAAPass.html.md b/docs/pages/FXAAPass.html.md
new file mode 100644
index 00000000000000..d20ec0f6392289
--- /dev/null
+++ b/docs/pages/FXAAPass.html.md
@@ -0,0 +1,46 @@
+*Inheritance: Pass → ShaderPass →*
+
+# FXAAPass
+
+A pass for applying FXAA.
+
+## Code Example
+
+```js
+const fxaaPass = new FXAAPass();
+composer.addPass( fxaaPass );
+```
+
+## Import
+
+FXAAPass is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { FXAAPass } from 'three/addons/postprocessing/FXAAPass.js';
+```
+
+## Constructor
+
+### new FXAAPass()
+
+Constructs a new FXAA pass.
+
+## Methods
+
+### .setSize( width : number, height : number )
+
+Sets the size of the pass.
+
+**width**
+
+The width to set.
+
+**height**
+
+The height to set.
+
+**Overrides:** [ShaderPass#setSize](ShaderPass.html#setSize)
+
+## Source
+
+[examples/jsm/postprocessing/FXAAPass.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/FXAAPass.js)
\ No newline at end of file
diff --git a/docs/pages/FigureEightPolynomialKnot.html.md b/docs/pages/FigureEightPolynomialKnot.html.md
new file mode 100644
index 00000000000000..5c9e389cfaceda
--- /dev/null
+++ b/docs/pages/FigureEightPolynomialKnot.html.md
@@ -0,0 +1,55 @@
+*Inheritance: Curve →*
+
+# FigureEightPolynomialKnot
+
+A Figure Eight Polynomial Knot.
+
+## Import
+
+FigureEightPolynomialKnot is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { FigureEightPolynomialKnot } from 'three/addons/curves/CurveExtras.js';
+```
+
+## Constructor
+
+### new FigureEightPolynomialKnot( scale : number )
+
+Constructs a new Figure Eight Polynomial Knot.
+
+**scale**
+
+The curve's scale.
+
+Default is `1`.
+
+## Properties
+
+### .scale : number
+
+The curve's scale.
+
+Default is `1`.
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector3 ) : Vector3
+
+This method returns a vector in 3D space for the given interpolation factor.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve.
+
+## Source
+
+[examples/jsm/curves/CurveExtras.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/curves/CurveExtras.js)
\ No newline at end of file
diff --git a/docs/pages/FileLoader.html.md b/docs/pages/FileLoader.html.md
new file mode 100644
index 00000000000000..03d12177ba5f1a
--- /dev/null
+++ b/docs/pages/FileLoader.html.md
@@ -0,0 +1,94 @@
+*Inheritance: Loader →*
+
+# FileLoader
+
+A low level class for loading resources with the Fetch API, used internally by most loaders. It can also be used directly to load any file type that does not have a loader.
+
+This loader supports caching. If you want to use it, add `THREE.Cache.enabled = true;` once to your application.
+
+## Code Example
+
+```js
+const loader = new THREE.FileLoader();
+const data = await loader.loadAsync( 'example.txt' );
+```
+
+## Constructor
+
+### new FileLoader( manager : LoadingManager )
+
+Constructs a new file loader.
+
+**manager**
+
+The loading manager.
+
+## Properties
+
+### .mimeType : string
+
+The expected mime type. Valid values can be found [here](hhttps://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString#mimetype)
+
+### .responseType : 'arraybuffer' | 'blob' | 'document' | 'json' | ''
+
+The expected response type.
+
+Default is `''`.
+
+## Methods
+
+### .abort() : FileLoader
+
+Aborts ongoing fetch requests.
+
+**Overrides:** [Loader#abort](Loader.html#abort)
+
+**Returns:** A reference to this instance.
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback ) : any | undefined
+
+Starts loading from the given URL and pass the loaded response to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+**Returns:** The cached resource if available.
+
+### .setMimeType( value : string ) : FileLoader
+
+Sets the expected mime type of the loaded file.
+
+**value**
+
+The mime type.
+
+**Returns:** A reference to this file loader.
+
+### .setResponseType( value : 'arraybuffer' | 'blob' | 'document' | 'json' | '' ) : FileLoader
+
+Sets the expected response type.
+
+**value**
+
+The response type.
+
+**Returns:** A reference to this file loader.
+
+## Source
+
+[src/loaders/FileLoader.js](https://github.com/mrdoob/three.js/blob/master/src/loaders/FileLoader.js)
\ No newline at end of file
diff --git a/docs/pages/FilmNode.html.md b/docs/pages/FilmNode.html.md
new file mode 100644
index 00000000000000..ec1df1ac55f517
--- /dev/null
+++ b/docs/pages/FilmNode.html.md
@@ -0,0 +1,69 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# FilmNode
+
+Post processing node for creating a film grain effect.
+
+## Import
+
+FilmNode is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { film } from 'three/addons/tsl/display/FilmNode.js';
+```
+
+## Constructor
+
+### new FilmNode( inputNode : Node, intensityNode : Node., uvNode : Node. )
+
+Constructs a new film node.
+
+**inputNode**
+
+The node that represents the input of the effect.
+
+**intensityNode**
+
+A node that represents the effect's intensity.
+
+Default is `null`.
+
+**uvNode**
+
+A node that allows to pass custom (e.g. animated) uv data.
+
+Default is `null`.
+
+## Properties
+
+### .inputNode : Node
+
+The node that represents the input of the effect.
+
+### .intensityNode : Node.
+
+A node that represents the effect's intensity.
+
+Default is `null`.
+
+### .uvNode : Node.
+
+A node that allows to pass custom (e.g. animated) uv data.
+
+Default is `null`.
+
+## Methods
+
+### .setup( builder : NodeBuilder ) : ShaderCallNodeInternal
+
+This method is used to setup the effect's TSL code.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#setup](TempNode.html#setup)
+
+## Source
+
+[examples/jsm/tsl/display/FilmNode.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/tsl/display/FilmNode.js)
\ No newline at end of file
diff --git a/docs/pages/FilmPass.html.md b/docs/pages/FilmPass.html.md
new file mode 100644
index 00000000000000..3d96a5e52d5990
--- /dev/null
+++ b/docs/pages/FilmPass.html.md
@@ -0,0 +1,91 @@
+*Inheritance: Pass →*
+
+# FilmPass
+
+This pass can be used to create a film grain effect.
+
+## Code Example
+
+```js
+const filmPass = new FilmPass();
+composer.addPass( filmPass );
+```
+
+## Import
+
+FilmPass is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { FilmPass } from 'three/addons/postprocessing/FilmPass.js';
+```
+
+## Constructor
+
+### new FilmPass( intensity : number, grayscale : boolean )
+
+Constructs a new film pass.
+
+**intensity**
+
+The grain intensity in the range `[0,1]` (0 = no effect, 1 = full effect).
+
+Default is `0.5`.
+
+**grayscale**
+
+Whether to apply a grayscale effect or not.
+
+Default is `false`.
+
+## Properties
+
+### .material : ShaderMaterial
+
+The pass material.
+
+### .uniforms : Object
+
+The pass uniforms. Use this object if you want to update the `intensity` or `grayscale` values at runtime.
+
+```js
+pass.uniforms.intensity.value = 1;
+pass.uniforms.grayscale.value = true;
+```
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever the pass is no longer used in your app.
+
+**Overrides:** [Pass#dispose](Pass.html#dispose)
+
+### .render( renderer : WebGLRenderer, writeBuffer : WebGLRenderTarget, readBuffer : WebGLRenderTarget, deltaTime : number, maskActive : boolean )
+
+Performs the film pass.
+
+**renderer**
+
+The renderer.
+
+**writeBuffer**
+
+The write buffer. This buffer is intended as the rendering destination for the pass.
+
+**readBuffer**
+
+The read buffer. The pass can access the result from the previous pass from this buffer.
+
+**deltaTime**
+
+The delta time in seconds.
+
+**maskActive**
+
+Whether masking is active or not.
+
+**Overrides:** [Pass#render](Pass.html#render)
+
+## Source
+
+[examples/jsm/postprocessing/FilmPass.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/FilmPass.js)
\ No newline at end of file
diff --git a/docs/pages/FirstPersonControls.html.md b/docs/pages/FirstPersonControls.html.md
new file mode 100644
index 00000000000000..fe740cd21315f3
--- /dev/null
+++ b/docs/pages/FirstPersonControls.html.md
@@ -0,0 +1,137 @@
+*Inheritance: EventDispatcher → Controls →*
+
+# FirstPersonControls
+
+This class is an alternative implementation of [FlyControls](FlyControls.html).
+
+## Import
+
+FirstPersonControls is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { FirstPersonControls } from 'three/addons/controls/FirstPersonControls.js';
+```
+
+## Constructor
+
+### new FirstPersonControls( object : Object3D, domElement : HTMLElement )
+
+Constructs a new controls instance.
+
+**object**
+
+The object that is managed by the controls.
+
+**domElement**
+
+The HTML element used for event listeners.
+
+Default is `null`.
+
+## Properties
+
+### .activeLook : boolean
+
+Whether it's possible to look around or not.
+
+Default is `true`.
+
+### .autoForward : boolean
+
+Whether the camera is automatically moved forward or not.
+
+Default is `false`.
+
+### .constrainVertical : boolean
+
+Whether or not looking around is vertically constrained by `verticalMin` and `verticalMax`.
+
+Default is `false`.
+
+### .heightCoef : number
+
+Determines how much faster the camera moves when it's y-component is near `heightMax`.
+
+Default is `1`.
+
+### .heightMax : number
+
+Upper camera height limit used for movement speed adjustment.
+
+Default is `1`.
+
+### .heightMin : number
+
+Lower camera height limit used for movement speed adjustment.
+
+Default is `0`.
+
+### .heightSpeed : boolean
+
+Whether or not the camera's height influences the forward movement speed. Use the properties `heightCoef`, `heightMin` and `heightMax` for configuration.
+
+Default is `false`.
+
+### .lookSpeed : number
+
+The look around speed.
+
+Default is `0.005`.
+
+### .lookVertical : boolean
+
+Whether it's possible to vertically look around or not.
+
+Default is `true`.
+
+### .mouseDragOn : boolean (readonly)
+
+Whether the mouse is pressed down or not.
+
+Default is `false`.
+
+### .movementSpeed : number
+
+The movement speed.
+
+Default is `1`.
+
+### .verticalMax : number
+
+How far you can vertically look around, upper limit. Range is `0` to `Math.PI` in radians.
+
+Default is `0`.
+
+### .verticalMin : number
+
+How far you can vertically look around, lower limit. Range is `0` to `Math.PI` in radians.
+
+Default is `0`.
+
+## Methods
+
+### .handleResize()
+
+Must be called if the application window is resized.
+
+### .lookAt( x : number | Vector3, y : number, z : number ) : FirstPersonControls
+
+Rotates the camera towards the defined target position.
+
+**x**
+
+The x coordinate of the target position or alternatively a vector representing the target position.
+
+**y**
+
+The y coordinate of the target position.
+
+**z**
+
+The z coordinate of the target position.
+
+**Returns:** A reference to this controls.
+
+## Source
+
+[examples/jsm/controls/FirstPersonControls.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/controls/FirstPersonControls.js)
\ No newline at end of file
diff --git a/docs/pages/FlakesTexture.html.md b/docs/pages/FlakesTexture.html.md
new file mode 100644
index 00000000000000..d362e687015e4a
--- /dev/null
+++ b/docs/pages/FlakesTexture.html.md
@@ -0,0 +1,35 @@
+# FlakesTexture
+
+Utility class for generating a flakes texture image. This image might be used as a normal map to produce a car paint like effect.
+
+## Import
+
+FlakesTexture is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { FlakesTexture } from 'three/addons/textures/FlakesTexture.js';
+```
+
+## Constructor
+
+### new FlakesTexture( width : number, height : number ) : HTMLCanvasElement
+
+Generates a new flakes texture image. The result is a canvas that can be used as an input for [CanvasTexture](CanvasTexture.html).
+
+**width**
+
+The width of the image.
+
+Default is `512`.
+
+**height**
+
+The height of the image.
+
+Default is `512`.
+
+**Returns:** The generated image.
+
+## Source
+
+[examples/jsm/textures/FlakesTexture.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/textures/FlakesTexture.js)
\ No newline at end of file
diff --git a/docs/pages/FlipNode.html.md b/docs/pages/FlipNode.html.md
new file mode 100644
index 00000000000000..187022e3138449
--- /dev/null
+++ b/docs/pages/FlipNode.html.md
@@ -0,0 +1,59 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# FlipNode
+
+This module is part of the TSL core and usually not used in app level code. It represents a flip operation during the shader generation process meaning it flips normalized values with the following formula:
+
+`FlipNode` is internally used to implement any `flipXYZW()`, `flipRGBA()` and `flipSTPQ()` method invocations on node objects. For example:
+
+```js
+uvNode = uvNode.flipY();
+```
+
+## Code Example
+
+```js
+x = 1 - x;
+```
+
+## Constructor
+
+### new FlipNode( sourceNode : Node, components : string )
+
+Constructs a new flip node.
+
+**sourceNode**
+
+The node which component(s) should be flipped.
+
+**components**
+
+The components that should be flipped e.g. `'x'` or `'xy'`.
+
+## Properties
+
+### .components : string
+
+The components that should be flipped e.g. `'x'` or `'xy'`.
+
+### .sourceNode : Node
+
+The node which component(s) should be flipped.
+
+## Methods
+
+### .getNodeType( builder : NodeBuilder ) : string
+
+This method is overwritten since the node type is inferred from the source node.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#getNodeType](TempNode.html#getNodeType)
+
+**Returns:** The node type.
+
+## Source
+
+[src/nodes/utils/FlipNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/utils/FlipNode.js)
\ No newline at end of file
diff --git a/docs/pages/Float16BufferAttribute.html.md b/docs/pages/Float16BufferAttribute.html.md
new file mode 100644
index 00000000000000..6ab8174a25ae03
--- /dev/null
+++ b/docs/pages/Float16BufferAttribute.html.md
@@ -0,0 +1,31 @@
+*Inheritance: BufferAttribute →*
+
+# Float16BufferAttribute
+
+Convenient class that can be used when creating a `Float16` buffer attribute with a plain `Array` instance.
+
+This class automatically converts to and from FP16 via `Uint16Array` since `Float16Array` browser support is still problematic.
+
+## Constructor
+
+### new Float16BufferAttribute( array : Array. | Uint16Array, itemSize : number, normalized : boolean )
+
+Constructs a new buffer attribute.
+
+**array**
+
+The array holding the attribute data.
+
+**itemSize**
+
+The item size.
+
+**normalized**
+
+Whether the data are normalized or not.
+
+Default is `false`.
+
+## Source
+
+[src/core/BufferAttribute.js](https://github.com/mrdoob/three.js/blob/master/src/core/BufferAttribute.js)
\ No newline at end of file
diff --git a/docs/pages/Float32BufferAttribute.html.md b/docs/pages/Float32BufferAttribute.html.md
new file mode 100644
index 00000000000000..f9b4dfcc94ab3e
--- /dev/null
+++ b/docs/pages/Float32BufferAttribute.html.md
@@ -0,0 +1,29 @@
+*Inheritance: BufferAttribute →*
+
+# Float32BufferAttribute
+
+Convenient class that can be used when creating a `Float32` buffer attribute with a plain `Array` instance.
+
+## Constructor
+
+### new Float32BufferAttribute( array : Array. | Float32Array, itemSize : number, normalized : boolean )
+
+Constructs a new buffer attribute.
+
+**array**
+
+The array holding the attribute data.
+
+**itemSize**
+
+The item size.
+
+**normalized**
+
+Whether the data are normalized or not.
+
+Default is `false`.
+
+## Source
+
+[src/core/BufferAttribute.js](https://github.com/mrdoob/three.js/blob/master/src/core/BufferAttribute.js)
\ No newline at end of file
diff --git a/docs/pages/Flow.html.md b/docs/pages/Flow.html.md
new file mode 100644
index 00000000000000..7d6ad25707dd23
--- /dev/null
+++ b/docs/pages/Flow.html.md
@@ -0,0 +1,59 @@
+# Flow
+
+A modifier for making meshes bend around curves.
+
+This module can only be used with [WebGLRenderer](WebGLRenderer.html). When using [WebGPURenderer](WebGPURenderer.html), import the class from `CurveModifierGPU.js`.
+
+## Import
+
+Flow is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { Flow } from 'three/addons/modifiers/CurveModifier.js';
+```
+
+## Constructor
+
+### new Flow( mesh : Mesh, numberOfCurves : number )
+
+Constructs a new Flow instance.
+
+**mesh**
+
+The mesh to clone and modify to bend around the curve.
+
+**numberOfCurves**
+
+The amount of space that should preallocated for additional curves.
+
+Default is `1`.
+
+## Classes
+
+[Flow](Flow.html)
+
+## Methods
+
+### .moveAlongCurve( amount : number )
+
+Moves the mesh along the curve.
+
+**amount**
+
+The offset.
+
+### .updateCurve( index : number, curve : Curve )
+
+Updates the curve for the given curve index.
+
+**index**
+
+The curve index.
+
+**curve**
+
+The curve that should be used to bend the mesh.
+
+## Source
+
+[examples/jsm/modifiers/CurveModifier.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/modifiers/CurveModifier.js)
\ No newline at end of file
diff --git a/docs/pages/FlyControls.html.md b/docs/pages/FlyControls.html.md
new file mode 100644
index 00000000000000..17f0e285da7517
--- /dev/null
+++ b/docs/pages/FlyControls.html.md
@@ -0,0 +1,69 @@
+*Inheritance: EventDispatcher → Controls →*
+
+# FlyControls
+
+This class enables a navigation similar to fly modes in DCC tools like Blender. You can arbitrarily transform the camera in 3D space without any limitations (e.g. focus on a specific target).
+
+## Import
+
+FlyControls is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { FlyControls } from 'three/addons/controls/FlyControls.js';
+```
+
+## Constructor
+
+### new FlyControls( object : Object3D, domElement : HTMLElement )
+
+Constructs a new controls instance.
+
+**object**
+
+The object that is managed by the controls.
+
+**domElement**
+
+The HTML element used for event listeners.
+
+Default is `null`.
+
+## Properties
+
+### .autoForward : boolean
+
+If set to `true`, the camera automatically moves forward (and does not stop) when initially translated.
+
+Default is `false`.
+
+### .dragToLook : boolean
+
+If set to `true`, you can only look around by performing a drag interaction.
+
+Default is `false`.
+
+### .movementSpeed : number
+
+The movement speed.
+
+Default is `1`.
+
+### .rollSpeed : number
+
+The rotation speed.
+
+Default is `0.005`.
+
+## Events
+
+### .change
+
+Fires when the camera has been transformed by the controls.
+
+##### Type:
+
+* Object
+
+## Source
+
+[examples/jsm/controls/FlyControls.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/controls/FlyControls.js)
\ No newline at end of file
diff --git a/docs/pages/Fog.html.md b/docs/pages/Fog.html.md
new file mode 100644
index 00000000000000..b972aef8cade75
--- /dev/null
+++ b/docs/pages/Fog.html.md
@@ -0,0 +1,82 @@
+# Fog
+
+This class can be used to define a linear fog that grows linearly denser with the distance.
+
+## Code Example
+
+```js
+const scene = new THREE.Scene();
+scene.fog = new THREE.Fog( 0xcccccc, 10, 15 );
+```
+
+## Constructor
+
+### new Fog( color : number | Color, near : number, far : number )
+
+Constructs a new fog.
+
+**color**
+
+The fog's color.
+
+**near**
+
+The minimum distance to start applying fog.
+
+Default is `1`.
+
+**far**
+
+The maximum distance at which fog stops being calculated and applied.
+
+Default is `1000`.
+
+## Properties
+
+### .color : Color
+
+The fog's color.
+
+### .far : number
+
+The maximum distance at which fog stops being calculated and applied. Objects that are more than `far` units away from the active camera won't be affected by fog.
+
+Default is `1000`.
+
+### .isFog : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .name : string
+
+The name of the fog.
+
+### .near : number
+
+The minimum distance to start applying fog. Objects that are less than `near` units from the active camera won't be affected by fog.
+
+Default is `1`.
+
+## Methods
+
+### .clone() : Fog
+
+Returns a new fog with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .toJSON( meta : Object | string ) : Object
+
+Serializes the fog into JSON.
+
+**meta**
+
+An optional value holding meta information about the serialization.
+
+**Returns:** A JSON object representing the serialized fog
+
+## Source
+
+[src/scenes/Fog.js](https://github.com/mrdoob/three.js/blob/master/src/scenes/Fog.js)
\ No newline at end of file
diff --git a/docs/pages/FogExp2.html.md b/docs/pages/FogExp2.html.md
new file mode 100644
index 00000000000000..a610b4325563eb
--- /dev/null
+++ b/docs/pages/FogExp2.html.md
@@ -0,0 +1,70 @@
+# FogExp2
+
+This class can be used to define an exponential squared fog, which gives a clear view near the camera and a faster than exponentially densening fog farther from the camera.
+
+## Code Example
+
+```js
+const scene = new THREE.Scene();
+scene.fog = new THREE.FogExp2( 0xcccccc, 0.002 );
+```
+
+## Constructor
+
+### new FogExp2( color : number | Color, density : number )
+
+Constructs a new fog.
+
+**color**
+
+The fog's color.
+
+**density**
+
+Defines how fast the fog will grow dense.
+
+Default is `0.00025`.
+
+## Properties
+
+### .color : Color
+
+The fog's color.
+
+### .density : number
+
+Defines how fast the fog will grow dense.
+
+Default is `0.00025`.
+
+### .isFogExp2 : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .name : string
+
+The name of the fog.
+
+## Methods
+
+### .clone() : FogExp2
+
+Returns a new fog with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .toJSON( meta : Object | string ) : Object
+
+Serializes the fog into JSON.
+
+**meta**
+
+An optional value holding meta information about the serialization.
+
+**Returns:** A JSON object representing the serialized fog
+
+## Source
+
+[src/scenes/FogExp2.js](https://github.com/mrdoob/three.js/blob/master/src/scenes/FogExp2.js)
\ No newline at end of file
diff --git a/docs/pages/Font.html.md b/docs/pages/Font.html.md
new file mode 100644
index 00000000000000..22b6e4ebb5b226
--- /dev/null
+++ b/docs/pages/Font.html.md
@@ -0,0 +1,53 @@
+# Font
+
+Class representing a font.
+
+## Constructor
+
+### new Font( data : Object )
+
+Constructs a new font.
+
+**data**
+
+The font data as JSON.
+
+## Properties
+
+### .data : Object
+
+The font data as JSON.
+
+### .isFont : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Methods
+
+### .generateShapes( text : string, size : number, direction : string ) : Array.
+
+Generates geometry shapes from the given text and size. The result of this method should be used with [ShapeGeometry](ShapeGeometry.html) to generate the actual geometry data.
+
+**text**
+
+The text.
+
+**size**
+
+The text size.
+
+Default is `100`.
+
+**direction**
+
+Char direction: ltr(left to right), rtl(right to left) & tb(top bottom).
+
+Default is `'ltr'`.
+
+**Returns:** An array of shapes representing the text.
+
+## Source
+
+[examples/jsm/loaders/FontLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/FontLoader.js)
\ No newline at end of file
diff --git a/docs/pages/FontLoader.html.md b/docs/pages/FontLoader.html.md
new file mode 100644
index 00000000000000..699299d20b6ab2
--- /dev/null
+++ b/docs/pages/FontLoader.html.md
@@ -0,0 +1,72 @@
+*Inheritance: Loader →*
+
+# FontLoader
+
+A loader for loading fonts.
+
+You can convert fonts online using [facetype.js](https://gero3.github.io/facetype.js/).
+
+## Code Example
+
+```js
+const loader = new FontLoader();
+const font = await loader.loadAsync( 'fonts/helvetiker_regular.typeface.json' );
+```
+
+## Import
+
+FontLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { FontLoader } from 'three/addons/loaders/FontLoader.js';
+```
+
+## Constructor
+
+### new FontLoader( manager : LoadingManager )
+
+Constructs a new font loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded font to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( json : Object ) : Font
+
+Parses the given font data and returns the resulting font.
+
+**json**
+
+The raw font data as a JSON object.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** The font.
+
+## Source
+
+[examples/jsm/loaders/FontLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/FontLoader.js)
\ No newline at end of file
diff --git a/docs/pages/FramebufferTexture.html.md b/docs/pages/FramebufferTexture.html.md
new file mode 100644
index 00000000000000..fd4abf8228e180
--- /dev/null
+++ b/docs/pages/FramebufferTexture.html.md
@@ -0,0 +1,76 @@
+*Inheritance: EventDispatcher → Texture →*
+
+# FramebufferTexture
+
+This class can only be used in combination with `copyFramebufferToTexture()` methods of renderers. It extracts the contents of the current bound framebuffer and provides it as a texture for further usage.
+
+## Code Example
+
+```js
+const pixelRatio = window.devicePixelRatio;
+const textureSize = 128 * pixelRatio;
+const frameTexture = new FramebufferTexture( textureSize, textureSize );
+// calculate start position for copying part of the frame data
+const vector = new Vector2();
+vector.x = ( window.innerWidth * pixelRatio / 2 ) - ( textureSize / 2 );
+vector.y = ( window.innerHeight * pixelRatio / 2 ) - ( textureSize / 2 );
+renderer.render( scene, camera );
+// copy part of the rendered frame into the framebuffer texture
+renderer.copyFramebufferToTexture( frameTexture, vector );
+```
+
+## Constructor
+
+### new FramebufferTexture( width : number, height : number )
+
+Constructs a new framebuffer texture.
+
+**width**
+
+The width of the texture.
+
+**height**
+
+The height of the texture.
+
+## Properties
+
+### .generateMipmaps : boolean
+
+Whether to generate mipmaps (if possible) for a texture.
+
+Overwritten and set to `false` by default.
+
+Default is `false`.
+
+**Overrides:** [Texture#generateMipmaps](Texture.html#generateMipmaps)
+
+### .isFramebufferTexture : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .magFilter : NearestFilter | NearestMipmapNearestFilter | NearestMipmapLinearFilter | LinearFilter | LinearMipmapNearestFilter | LinearMipmapLinearFilter
+
+How the texture is sampled when a texel covers more than one pixel.
+
+Overwritten and set to `NearestFilter` by default to disable filtering.
+
+Default is `NearestFilter`.
+
+**Overrides:** [Texture#magFilter](Texture.html#magFilter)
+
+### .minFilter : NearestFilter | NearestMipmapNearestFilter | NearestMipmapLinearFilter | LinearFilter | LinearMipmapNearestFilter | LinearMipmapLinearFilter
+
+How the texture is sampled when a texel covers less than one pixel.
+
+Overwritten and set to `NearestFilter` by default to disable filtering.
+
+Default is `NearestFilter`.
+
+**Overrides:** [Texture#minFilter](Texture.html#minFilter)
+
+## Source
+
+[src/textures/FramebufferTexture.js](https://github.com/mrdoob/three.js/blob/master/src/textures/FramebufferTexture.js)
\ No newline at end of file
diff --git a/docs/pages/FrontFacingNode.html.md b/docs/pages/FrontFacingNode.html.md
new file mode 100644
index 00000000000000..84f674aaa428bb
--- /dev/null
+++ b/docs/pages/FrontFacingNode.html.md
@@ -0,0 +1,23 @@
+*Inheritance: EventDispatcher → Node →*
+
+# FrontFacingNode
+
+This node can be used to evaluate whether a primitive is front or back facing.
+
+## Constructor
+
+### new FrontFacingNode()
+
+Constructs a new front facing node.
+
+## Properties
+
+### .isFrontFacingNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/nodes/display/FrontFacingNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/display/FrontFacingNode.js)
\ No newline at end of file
diff --git a/docs/pages/Frustum.html.md b/docs/pages/Frustum.html.md
new file mode 100644
index 00000000000000..ed655c56cc86cf
--- /dev/null
+++ b/docs/pages/Frustum.html.md
@@ -0,0 +1,165 @@
+# Frustum
+
+Frustums are used to determine what is inside the camera's field of view. They help speed up the rendering process - objects which lie outside a camera's frustum can safely be excluded from rendering.
+
+This class is mainly intended for use internally by a renderer.
+
+## Constructor
+
+### new Frustum( p0 : Plane, p1 : Plane, p2 : Plane, p3 : Plane, p4 : Plane, p5 : Plane )
+
+Constructs a new frustum.
+
+**p0**
+
+The first plane that encloses the frustum.
+
+**p1**
+
+The second plane that encloses the frustum.
+
+**p2**
+
+The third plane that encloses the frustum.
+
+**p3**
+
+The fourth plane that encloses the frustum.
+
+**p4**
+
+The fifth plane that encloses the frustum.
+
+**p5**
+
+The sixth plane that encloses the frustum.
+
+## Properties
+
+### .planes : Array.
+
+This array holds the planes that enclose the frustum.
+
+## Methods
+
+### .clone() : Frustum
+
+Returns a new frustum with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .containsPoint( point : Vector3 ) : boolean
+
+Returns `true` if the given point lies within the frustum.
+
+**point**
+
+The point to test.
+
+**Returns:** Whether the point lies within this frustum or not.
+
+### .copy( frustum : Frustum ) : Frustum
+
+Copies the values of the given frustum to this instance.
+
+**frustum**
+
+The frustum to copy.
+
+**Returns:** A reference to this frustum.
+
+### .intersectsBox( box : Box3 ) : boolean
+
+Returns `true` if the given bounding box is intersecting this frustum.
+
+**box**
+
+The bounding box to test.
+
+**Returns:** Whether the bounding box is intersecting this frustum or not.
+
+### .intersectsObject( object : Object3D ) : boolean
+
+Returns `true` if the 3D object's bounding sphere is intersecting this frustum.
+
+Note that the 3D object must have a geometry so that the bounding sphere can be calculated.
+
+**object**
+
+The 3D object to test.
+
+**Returns:** Whether the 3D object's bounding sphere is intersecting this frustum or not.
+
+### .intersectsSphere( sphere : Sphere ) : boolean
+
+Returns `true` if the given bounding sphere is intersecting this frustum.
+
+**sphere**
+
+The bounding sphere to test.
+
+**Returns:** Whether the bounding sphere is intersecting this frustum or not.
+
+### .intersectsSprite( sprite : Sprite ) : boolean
+
+Returns `true` if the given sprite is intersecting this frustum.
+
+**sprite**
+
+The sprite to test.
+
+**Returns:** Whether the sprite is intersecting this frustum or not.
+
+### .set( p0 : Plane, p1 : Plane, p2 : Plane, p3 : Plane, p4 : Plane, p5 : Plane ) : Frustum
+
+Sets the frustum planes by copying the given planes.
+
+**p0**
+
+The first plane that encloses the frustum.
+
+**p1**
+
+The second plane that encloses the frustum.
+
+**p2**
+
+The third plane that encloses the frustum.
+
+**p3**
+
+The fourth plane that encloses the frustum.
+
+**p4**
+
+The fifth plane that encloses the frustum.
+
+**p5**
+
+The sixth plane that encloses the frustum.
+
+**Returns:** A reference to this frustum.
+
+### .setFromProjectionMatrix( m : Matrix4, coordinateSystem : WebGLCoordinateSystem | WebGPUCoordinateSystem, reversedDepth : boolean ) : Frustum
+
+Sets the frustum planes from the given projection matrix.
+
+**m**
+
+The projection matrix.
+
+**coordinateSystem**
+
+The coordinate system.
+
+**reversedDepth**
+
+Whether to use a reversed depth.
+
+Default is `false`.
+
+**Returns:** A reference to this frustum.
+
+## Source
+
+[src/math/Frustum.js](https://github.com/mrdoob/three.js/blob/master/src/math/Frustum.js)
\ No newline at end of file
diff --git a/docs/pages/FrustumArray.html.md b/docs/pages/FrustumArray.html.md
new file mode 100644
index 00000000000000..a7d437ec41db98
--- /dev/null
+++ b/docs/pages/FrustumArray.html.md
@@ -0,0 +1,99 @@
+# FrustumArray
+
+FrustumArray is used to determine if an object is visible in at least one camera from an array of cameras. This is particularly useful for multi-view renderers.
+
+## Constructor
+
+### new FrustumArray()
+
+Constructs a new frustum array.
+
+## Properties
+
+### .coordinateSystem : WebGLCoordinateSystem | WebGPUCoordinateSystem
+
+The coordinate system to use.
+
+Default is `WebGLCoordinateSystem`.
+
+## Methods
+
+### .clone() : FrustumArray
+
+Returns a new frustum array with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .containsPoint( point : Vector3, cameraArray : Object ) : boolean
+
+Returns `true` if the given point lies within any frustum from the camera array.
+
+**point**
+
+The point to test.
+
+**cameraArray**
+
+An object with a cameras property containing an array of cameras.
+
+**Returns:** Whether the point is visible in any camera.
+
+### .intersectsBox( box : Box3, cameraArray : Object ) : boolean
+
+Returns `true` if the given bounding box is intersecting any frustum from the camera array.
+
+**box**
+
+The bounding box to test.
+
+**cameraArray**
+
+An object with a cameras property containing an array of cameras.
+
+**Returns:** Whether the box is visible in any camera.
+
+### .intersectsObject( object : Object3D, cameraArray : Object ) : boolean
+
+Returns `true` if the 3D object's bounding sphere is intersecting any frustum from the camera array.
+
+**object**
+
+The 3D object to test.
+
+**cameraArray**
+
+An object with a cameras property containing an array of cameras.
+
+**Returns:** Whether the 3D object is visible in any camera.
+
+### .intersectsSphere( sphere : Sphere, cameraArray : Object ) : boolean
+
+Returns `true` if the given bounding sphere is intersecting any frustum from the camera array.
+
+**sphere**
+
+The bounding sphere to test.
+
+**cameraArray**
+
+An object with a cameras property containing an array of cameras.
+
+**Returns:** Whether the sphere is visible in any camera.
+
+### .intersectsSprite( sprite : Sprite, cameraArray : Object ) : boolean
+
+Returns `true` if the given sprite is intersecting any frustum from the camera array.
+
+**sprite**
+
+The sprite to test.
+
+**cameraArray**
+
+An object with a cameras property containing an array of cameras.
+
+**Returns:** Whether the sprite is visible in any camera.
+
+## Source
+
+[src/math/FrustumArray.js](https://github.com/mrdoob/three.js/blob/master/src/math/FrustumArray.js)
\ No newline at end of file
diff --git a/docs/pages/FullScreenQuad.html.md b/docs/pages/FullScreenQuad.html.md
new file mode 100644
index 00000000000000..602453a97e9329
--- /dev/null
+++ b/docs/pages/FullScreenQuad.html.md
@@ -0,0 +1,53 @@
+*Inheritance: EventDispatcher → Object3D → Mesh →*
+
+# FullScreenQuad
+
+This module is a helper for passes which need to render a full screen effect which is quite common in context of post processing.
+
+The intended usage is to reuse a single full screen quad for rendering subsequent passes by just reassigning the `material` reference.
+
+This module can only be used with [WebGLRenderer](WebGLRenderer.html).
+
+## Import
+
+FullScreenQuad is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { FullScreenQuad } from 'three/addons/postprocessing/Pass.js';
+```
+
+## Constructor
+
+### new FullScreenQuad( material : Material )
+
+Constructs a new full screen quad.
+
+**material**
+
+The material to render te full screen quad with.
+
+## Properties
+
+### .material : Material
+
+The quad's material.
+
+**Overrides:** [Mesh#material](Mesh.html#material)
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever the instance is no longer used in your app.
+
+### .render( renderer : WebGLRenderer )
+
+Renders the full screen quad.
+
+**renderer**
+
+The renderer.
+
+## Source
+
+[examples/jsm/postprocessing/Pass.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/Pass.js)
\ No newline at end of file
diff --git a/docs/pages/FunctionCallNode.html.md b/docs/pages/FunctionCallNode.html.md
new file mode 100644
index 00000000000000..278d36ae6b3c78
--- /dev/null
+++ b/docs/pages/FunctionCallNode.html.md
@@ -0,0 +1,87 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# FunctionCallNode
+
+This module represents the call of a [FunctionNode](FunctionNode.html). Developers are usually not confronted with this module since they use the predefined TSL syntax `wgslFn` and `glslFn` which encapsulate this logic.
+
+## Constructor
+
+### new FunctionCallNode( functionNode : FunctionNode, parameters : Object. )
+
+Constructs a new function call node.
+
+**functionNode**
+
+The function node.
+
+Default is `null`.
+
+**parameters**
+
+The parameters for the function call.
+
+Default is `{}`.
+
+## Properties
+
+### .functionNode : FunctionNode
+
+The function node.
+
+Default is `null`.
+
+### .parameters : Object.
+
+The parameters of the function call.
+
+Default is `{}`.
+
+## Methods
+
+### .getMemberType( builder : NodeBuilder, name : string ) : string
+
+Returns the function node of this function call node.
+
+**builder**
+
+The current node builder.
+
+**name**
+
+The name of the member.
+
+**Overrides:** [TempNode#getMemberType](TempNode.html#getMemberType)
+
+**Returns:** The type of the member.
+
+### .getNodeType( builder : NodeBuilder ) : string
+
+Returns the type of this function call node.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#getNodeType](TempNode.html#getNodeType)
+
+**Returns:** The type of this node.
+
+### .getParameters() : Object.
+
+Returns the parameters of the function call node.
+
+**Returns:** The parameters of this node.
+
+### .setParameters( parameters : Object. ) : FunctionCallNode
+
+Sets the parameters of the function call node.
+
+**parameters**
+
+The parameters to set.
+
+**Returns:** A reference to this node.
+
+## Source
+
+[src/nodes/code/FunctionCallNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/code/FunctionCallNode.js)
\ No newline at end of file
diff --git a/docs/pages/FunctionNode.html.md b/docs/pages/FunctionNode.html.md
new file mode 100644
index 00000000000000..e58e29dd8f514a
--- /dev/null
+++ b/docs/pages/FunctionNode.html.md
@@ -0,0 +1,105 @@
+*Inheritance: EventDispatcher → Node → CodeNode →*
+
+# FunctionNode
+
+This class represents a native shader function. It can be used to implement certain aspects of a node material with native shader code. There are two predefined TSL functions for easier usage.
+
+* `wgslFn`: Creates a WGSL function node.
+* `glslFn`: Creates a GLSL function node.
+
+A basic example with one include looks like so:
+
+## Code Example
+
+```js
+const desaturateWGSLFn = wgslFn( `
+ fn desaturate( color:vec3 ) -> vec3 {
+ let lum = vec3( 0.299, 0.587, 0.114 );
+ return vec3( dot( lum, color ) );
+ }`
+);
+const someWGSLFn = wgslFn( `
+ fn someFn( color:vec3 ) -> vec3 {
+ return desaturate( color );
+ }
+`, [ desaturateWGSLFn ] );
+material.colorNode = someWGSLFn( { color: texture( map ) } );
+```
+
+## Constructor
+
+### new FunctionNode( code : string, includes : Array., language : 'js' | 'wgsl' | 'glsl' )
+
+Constructs a new function node.
+
+**code**
+
+The native code.
+
+Default is `''`.
+
+**includes**
+
+An array of includes.
+
+Default is `[]`.
+
+**language**
+
+The used language.
+
+Default is `''`.
+
+## Methods
+
+### .getInputs( builder : NodeBuilder ) : Array.
+
+Returns the inputs of this function node.
+
+**builder**
+
+The current node builder.
+
+**Returns:** The inputs.
+
+### .getMemberType( builder : NodeBuilder, name : string ) : string
+
+Returns the type of a member of this function node.
+
+**builder**
+
+The current node builder.
+
+**name**
+
+The name of the member.
+
+**Overrides:** [CodeNode#getMemberType](CodeNode.html#getMemberType)
+
+**Returns:** The type of the member.
+
+### .getNodeFunction( builder : NodeBuilder ) : NodeFunction
+
+Returns the node function for this function node.
+
+**builder**
+
+The current node builder.
+
+**Returns:** The node function.
+
+### .getNodeType( builder : NodeBuilder ) : string
+
+Returns the type of this function node.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [CodeNode#getNodeType](CodeNode.html#getNodeType)
+
+**Returns:** The type.
+
+## Source
+
+[src/nodes/code/FunctionNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/code/FunctionNode.js)
\ No newline at end of file
diff --git a/docs/pages/FunctionOverloadingNode.html.md b/docs/pages/FunctionOverloadingNode.html.md
new file mode 100644
index 00000000000000..a96599e173fa9f
--- /dev/null
+++ b/docs/pages/FunctionOverloadingNode.html.md
@@ -0,0 +1,77 @@
+*Inheritance: EventDispatcher → Node →*
+
+# FunctionOverloadingNode
+
+This class allows to define multiple overloaded versions of the same function. Depending on the parameters of the function call, the node picks the best-fit overloaded version.
+
+## Constructor
+
+### new FunctionOverloadingNode( functionNodes : Array., …parametersNodes : Node )
+
+Constructs a new function overloading node.
+
+**functionNodes**
+
+Array of `Fn` function definitions.
+
+**parametersNodes**
+
+A list of parameter nodes.
+
+## Properties
+
+### .functionNodes : Array.
+
+Array of `Fn` function definitions.
+
+### .global : boolean
+
+This node is marked as global.
+
+Default is `true`.
+
+**Overrides:** [Node#global](Node.html#global)
+
+### .parametersNodes : Array.
+
+A list of parameter nodes.
+
+## Methods
+
+### .getCandidateFn( builder : NodeBuilder ) : FunctionNode
+
+Returns the candidate function for the current parameters.
+
+**builder**
+
+The current node builder.
+
+**Returns:** The candidate function.
+
+### .getNodeType( builder : NodeBuilder ) : string
+
+This method is overwritten since the node type is inferred from the function's return type.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [Node#getNodeType](Node.html#getNodeType)
+
+**Returns:** The node type.
+
+### .setup( builder : NodeBuilder ) : Node
+
+Sets up the node for the current parameters.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [Node#setup](Node.html#setup)
+
+**Returns:** The setup node.
+
+## Source
+
+[src/nodes/utils/FunctionOverloadingNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/utils/FunctionOverloadingNode.js)
\ No newline at end of file
diff --git a/docs/pages/GCodeLoader.html.md b/docs/pages/GCodeLoader.html.md
new file mode 100644
index 00000000000000..68f2b8271592db
--- /dev/null
+++ b/docs/pages/GCodeLoader.html.md
@@ -0,0 +1,81 @@
+*Inheritance: Loader →*
+
+# GCodeLoader
+
+A loader for the GCode format.
+
+GCode files are usually used for 3D printing or CNC applications.
+
+## Code Example
+
+```js
+const loader = new GCodeLoader();
+const object = await loader.loadAsync( 'models/gcode/benchy.gcode' );
+scene.add( object );
+```
+
+## Import
+
+GCodeLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { GCodeLoader } from 'three/addons/loaders/GCodeLoader.js';
+```
+
+## Constructor
+
+### new GCodeLoader( manager : LoadingManager )
+
+Constructs a new GCode loader.
+
+**manager**
+
+The loading manager.
+
+## Properties
+
+### .splitLayer : boolean
+
+Whether to split layers or not.
+
+Default is `false`.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded GCode asset to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( data : string ) : Group
+
+Parses the given GCode data and returns a group with lines.
+
+**data**
+
+The raw Gcode data as a string.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** The parsed GCode asset.
+
+## Source
+
+[examples/jsm/loaders/GCodeLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/GCodeLoader.js)
\ No newline at end of file
diff --git a/docs/pages/GLBufferAttribute.html.md b/docs/pages/GLBufferAttribute.html.md
new file mode 100644
index 00000000000000..ce75395bf04713
--- /dev/null
+++ b/docs/pages/GLBufferAttribute.html.md
@@ -0,0 +1,137 @@
+# GLBufferAttribute
+
+An alternative version of a buffer attribute with more control over the VBO.
+
+The renderer does not construct a VBO for this kind of attribute. Instead, it uses whatever VBO is passed in constructor and can later be altered via the `buffer` property.
+
+The most common use case for this class is when some kind of GPGPU calculation interferes or even produces the VBOs in question.
+
+Notice that this class can only be used with [WebGLRenderer](WebGLRenderer.html).
+
+## Constructor
+
+### new GLBufferAttribute( buffer : WebGLBuffer, type : number, itemSize : number, elementSize : number, count : number, normalized : boolean )
+
+Constructs a new GL buffer attribute.
+
+**buffer**
+
+The native WebGL buffer.
+
+**type**
+
+The native data type (e.g. `gl.FLOAT`).
+
+**itemSize**
+
+The item size.
+
+**elementSize**
+
+The corresponding size (in bytes) for the given `type` parameter.
+
+**count**
+
+The expected number of vertices in VBO.
+
+**normalized**
+
+Whether the data are normalized or not.
+
+Default is `false`.
+
+## Properties
+
+### .buffer : WebGLBuffer
+
+The native WebGL buffer.
+
+### .count : number
+
+The expected number of vertices in VBO.
+
+### .elementSize : number
+
+The corresponding size (in bytes) for the given `type` parameter.
+
+### .isGLBufferAttribute : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .itemSize : number
+
+The item size, see [BufferAttribute#itemSize](BufferAttribute.html#itemSize).
+
+### .name : string
+
+The name of the buffer attribute.
+
+### .needsUpdate : number
+
+Flag to indicate that this attribute has changed and should be re-sent to the GPU. Set this to `true` when you modify the value of the array.
+
+Default is `false`.
+
+### .normalized : boolean
+
+Applies to integer data only. Indicates how the underlying data in the buffer maps to the values in the GLSL code. For instance, if `buffer` contains data of `gl.UNSIGNED_SHORT`, and `normalized` is `true`, the values `0 - +65535` in the buffer data will be mapped to `0.0f - +1.0f` in the GLSL attribute. If `normalized` is `false`, the values will be converted to floats unmodified, i.e. `65535` becomes `65535.0f`.
+
+### .type : number
+
+The native data type.
+
+### .version : number
+
+A version number, incremented every time the `needsUpdate` is set to `true`.
+
+## Methods
+
+### .setBuffer( buffer : WebGLBuffer ) : BufferAttribute
+
+Sets the given native WebGL buffer.
+
+**buffer**
+
+The buffer to set.
+
+**Returns:** A reference to this instance.
+
+### .setCount( count : number ) : BufferAttribute
+
+Sets the count (the expected number of vertices in VBO).
+
+**count**
+
+The count.
+
+**Returns:** A reference to this instance.
+
+### .setItemSize( itemSize : number ) : BufferAttribute
+
+Sets the item size.
+
+**itemSize**
+
+The item size.
+
+**Returns:** A reference to this instance.
+
+### .setType( type : number, elementSize : number ) : BufferAttribute
+
+Sets the given native data type and element size.
+
+**type**
+
+The native data type (e.g. `gl.FLOAT`).
+
+**elementSize**
+
+The corresponding size (in bytes) for the given `type` parameter.
+
+**Returns:** A reference to this instance.
+
+## Source
+
+[src/core/GLBufferAttribute.js](https://github.com/mrdoob/three.js/blob/master/src/core/GLBufferAttribute.js)
\ No newline at end of file
diff --git a/docs/pages/GLSLNodeBuilder.html.md b/docs/pages/GLSLNodeBuilder.html.md
new file mode 100644
index 00000000000000..8c37c16121f58b
--- /dev/null
+++ b/docs/pages/GLSLNodeBuilder.html.md
@@ -0,0 +1,615 @@
+*Inheritance: NodeBuilder →*
+
+# GLSLNodeBuilder
+
+A node builder targeting GLSL.
+
+This module generates GLSL shader code from node materials and also generates the respective bindings and vertex buffer definitions. These data are later used by the renderer to create render and compute pipelines for render objects.
+
+## Constructor
+
+### new GLSLNodeBuilder( object : Object3D, renderer : Renderer )
+
+Constructs a new GLSL node builder renderer.
+
+**object**
+
+The 3D object.
+
+**renderer**
+
+The renderer.
+
+## Properties
+
+### .builtins : Object.>
+
+A dictionary that holds for each shader stage an Array of used builtins.
+
+### .extensions : Object.>
+
+A dictionary that holds for each shader stage a Map of used extensions.
+
+### .transforms : Array.>
+
+An array that holds objects defining the varying and attribute data in context of Transform Feedback.
+
+### .uniformGroups : Object.>
+
+A dictionary holds for each shader stage ('vertex', 'fragment', 'compute') another dictionary which manages UBOs per group ('render','frame','object').
+
+## Methods
+
+### .buildCode()
+
+Controls the code build of the shader stages.
+
+**Overrides:** [NodeBuilder#buildCode](NodeBuilder.html#buildCode)
+
+### .buildFunctionCode( shaderNode : ShaderNodeInternal ) : string
+
+Builds the given shader node.
+
+**shaderNode**
+
+The shader node.
+
+**Overrides:** [NodeBuilder#buildFunctionCode](NodeBuilder.html#buildFunctionCode)
+
+**Returns:** The GLSL function code.
+
+### .enableExtension( name : string, behavior : string, shaderStage : string )
+
+Enables the given extension.
+
+**name**
+
+The extension name.
+
+**behavior**
+
+The extension behavior.
+
+**shaderStage**
+
+The shader stage.
+
+Default is `this.shaderStage`.
+
+### .enableHardwareClipping( planeCount : string )
+
+Enables hardware clipping.
+
+**planeCount**
+
+The clipping plane count.
+
+### .enableMultiview()
+
+Enables multiview.
+
+### .generatePBO( storageArrayElementNode : StorageArrayElementNode ) : string
+
+Setups the Pixel Buffer Object (PBO) for the given storage buffer node.
+
+**storageArrayElementNode**
+
+The storage array element node.
+
+**Returns:** The property name.
+
+### .generateTexture( texture : Texture, textureProperty : string, uvSnippet : string, depthSnippet : string, offsetSnippet : string ) : string
+
+Generates the GLSL snippet for sampling/loading the given texture.
+
+**texture**
+
+The texture.
+
+**textureProperty**
+
+The name of the texture uniform in the shader.
+
+**uvSnippet**
+
+A GLSL snippet that represents texture coordinates used for sampling.
+
+**depthSnippet**
+
+A GLSL snippet that represents the 0-based texture array index to sample.
+
+**offsetSnippet**
+
+A GLSL snippet that represents the offset that will be applied to the unnormalized texture coordinate before sampling the texture.
+
+**Overrides:** [NodeBuilder#generateTexture](NodeBuilder.html#generateTexture)
+
+**Returns:** The GLSL snippet.
+
+### .generateTextureBias( texture : Texture, textureProperty : string, uvSnippet : string, biasSnippet : string, offsetSnippet : string ) : string
+
+Generates the GLSL snippet when sampling textures with a bias to the mip level.
+
+**texture**
+
+The texture.
+
+**textureProperty**
+
+The name of the texture uniform in the shader.
+
+**uvSnippet**
+
+A GLSL snippet that represents texture coordinates used for sampling.
+
+**biasSnippet**
+
+A GLSL snippet that represents the bias to apply to the mip level before sampling.
+
+**offsetSnippet**
+
+A GLSL snippet that represents the offset that will be applied to the unnormalized texture coordinate before sampling the texture.
+
+**Returns:** The GLSL snippet.
+
+### .generateTextureCompare( texture : Texture, textureProperty : string, uvSnippet : string, compareSnippet : string, depthSnippet : string, offsetSnippet : string, shaderStage : string ) : string
+
+Generates the GLSL snippet for sampling a depth texture and comparing the sampled depth values against a reference value.
+
+**texture**
+
+The texture.
+
+**textureProperty**
+
+The name of the texture uniform in the shader.
+
+**uvSnippet**
+
+A GLSL snippet that represents texture coordinates used for sampling.
+
+**compareSnippet**
+
+A GLSL snippet that represents the reference value.
+
+**depthSnippet**
+
+A GLSL snippet that represents 0-based texture array index to sample.
+
+**offsetSnippet**
+
+A GLSL snippet that represents the offset that will be applied to the unnormalized texture coordinate before sampling the texture.
+
+**shaderStage**
+
+The shader stage this code snippet is generated for.
+
+Default is `this.shaderStage`.
+
+**Returns:** The GLSL snippet.
+
+### .generateTextureGrad( texture : Texture, textureProperty : string, uvSnippet : string, gradSnippet : Array., offsetSnippet : string ) : string
+
+Generates the GLSL snippet for sampling/loading the given texture using explicit gradients.
+
+**texture**
+
+The texture.
+
+**textureProperty**
+
+The name of the texture uniform in the shader.
+
+**uvSnippet**
+
+A GLSL snippet that represents texture coordinates used for sampling.
+
+**gradSnippet**
+
+An array holding both gradient GLSL snippets.
+
+**offsetSnippet**
+
+A GLSL snippet that represents the offset that will be applied to the unnormalized texture coordinate before sampling the texture.
+
+**Returns:** The GLSL snippet.
+
+### .generateTextureLevel( texture : Texture, textureProperty : string, uvSnippet : string, levelSnippet : string, offsetSnippet : string ) : string
+
+Generates the GLSL snippet when sampling textures with explicit mip level.
+
+**texture**
+
+The texture.
+
+**textureProperty**
+
+The name of the texture uniform in the shader.
+
+**uvSnippet**
+
+A GLSL snippet that represents texture coordinates used for sampling.
+
+**levelSnippet**
+
+A GLSL snippet that represents the mip level, with level 0 containing a full size version of the texture.
+
+**offsetSnippet**
+
+A GLSL snippet that represents the offset that will be applied to the unnormalized texture coordinate before sampling the texture.
+
+**Returns:** The GLSL snippet.
+
+### .generateTextureLoad( texture : Texture, textureProperty : string, uvIndexSnippet : string, levelSnippet : string, depthSnippet : string, offsetSnippet : string ) : string
+
+Generates the GLSL snippet that reads a single texel from a texture without sampling or filtering.
+
+**texture**
+
+The texture.
+
+**textureProperty**
+
+The name of the texture uniform in the shader.
+
+**uvIndexSnippet**
+
+A GLSL snippet that represents texture coordinates used for sampling.
+
+**levelSnippet**
+
+A GLSL snippet that represents the mip level, with level 0 containing a full size version of the texture.
+
+**depthSnippet**
+
+A GLSL snippet that represents the 0-based texture array index to sample.
+
+**offsetSnippet**
+
+A GLSL snippet that represents the offset that will be applied to the unnormalized texture coordinate before sampling the texture.
+
+**Returns:** The GLSL snippet.
+
+### .getAttributes( shaderStage : string ) : string
+
+Returns the shader attributes of the given shader stage as a GLSL string.
+
+**shaderStage**
+
+The shader stage.
+
+**Overrides:** [NodeBuilder#getAttributes](NodeBuilder.html#getAttributes)
+
+**Returns:** The GLSL snippet that defines the shader attributes.
+
+### .getBitcastMethod( type : string, inputType : string ) : string
+
+Returns the bitcast method name for a given input and outputType.
+
+**type**
+
+The output type to bitcast to.
+
+**inputType**
+
+The input type of the.
+
+**Returns:** The resolved WGSL bitcast invocation.
+
+### .getClipDistance() : string
+
+Returns the clip distances builtin.
+
+**Returns:** The clip distances builtin.
+
+### .getDrawIndex() : string
+
+Returns the draw index builtin.
+
+**Overrides:** [NodeBuilder#getDrawIndex](NodeBuilder.html#getDrawIndex)
+
+**Returns:** The drawIndex shader string. Returns `null` if `WEBGL_multi_draw` isn't supported by the device.
+
+### .getExtensions( shaderStage : string ) : string
+
+Returns the enabled extensions of the given shader stage as a GLSL string.
+
+**shaderStage**
+
+The shader stage.
+
+**Returns:** The GLSL snippet that defines the enabled extensions.
+
+### .getFloatPackingMethod( encoding : string ) : string
+
+Returns the float packing method name for a given numeric encoding.
+
+**encoding**
+
+The numeric encoding that describes how the float values are mapped to the integer range.
+
+**Returns:** The resolved GLSL float packing method name.
+
+### .getFloatUnpackingMethod( encoding : string ) : string
+
+Returns the float unpacking method name for a given numeric encoding.
+
+**encoding**
+
+The numeric encoding that describes how the integer values are mapped to the float range.
+
+**Returns:** The resolved GLSL float unpacking method name.
+
+### .getFragCoord() : string
+
+Returns the frag coord builtin.
+
+**Overrides:** [NodeBuilder#getFragCoord](NodeBuilder.html#getFragCoord)
+
+**Returns:** The frag coord builtin.
+
+### .getFragDepth() : string
+
+Returns the frag depth builtin.
+
+**Returns:** The frag depth builtin.
+
+### .getFrontFacing() : string
+
+Returns the front facing builtin.
+
+**Overrides:** [NodeBuilder#getFrontFacing](NodeBuilder.html#getFrontFacing)
+
+**Returns:** The front facing builtin.
+
+### .getInstanceIndex() : string
+
+Contextually returns either the vertex stage instance index builtin or the linearized index of an compute invocation within a grid of workgroups.
+
+**Overrides:** [NodeBuilder#getInstanceIndex](NodeBuilder.html#getInstanceIndex)
+
+**Returns:** The instance index.
+
+### .getInvocationLocalIndex() : string
+
+Returns a builtin representing the index of an invocation within its workgroup.
+
+**Returns:** The invocation local index.
+
+### .getInvocationSubgroupIndex()
+
+Returns a builtin representing the index of an invocation within its subgroup.
+
+### .getMethod( method : string ) : string
+
+Returns the native shader method name for a given generic name.
+
+**method**
+
+The method name to resolve.
+
+**Overrides:** [NodeBuilder#getMethod](NodeBuilder.html#getMethod)
+
+**Returns:** The resolved GLSL method name.
+
+### .getOutputStructName() : string
+
+Returns the output struct name. Not relevant for GLSL.
+
+**Overrides:** [NodeBuilder#getOutputStructName](NodeBuilder.html#getOutputStructName)
+
+### .getPropertyName( node : Node, shaderStage : string ) : string
+
+Returns a GLSL snippet that represents the property name of the given node.
+
+**node**
+
+The node.
+
+**shaderStage**
+
+The shader stage this code snippet is generated for.
+
+Default is `this.shaderStage`.
+
+**Overrides:** [NodeBuilder#getPropertyName](NodeBuilder.html#getPropertyName)
+
+**Returns:** The property name.
+
+### .getStructMembers( struct : StructTypeNode ) : string
+
+Returns the members of the given struct type node as a GLSL string.
+
+**struct**
+
+The struct type node.
+
+**Returns:** The GLSL snippet that defines the struct members.
+
+### .getStructs( shaderStage : string ) : string
+
+Returns the structs of the given shader stage as a GLSL string.
+
+**shaderStage**
+
+The shader stage.
+
+**Returns:** The GLSL snippet that defines the structs.
+
+### .getSubgroupIndex()
+
+Returns a builtin representing the index of the current invocation's subgroup within its workgroup.
+
+### .getSubgroupSize()
+
+Returns a builtin representing the size of a subgroup within the current shader.
+
+### .getTernary( condSnippet : string, ifSnippet : string, elseSnippet : string ) : string
+
+Returns the native snippet for a ternary operation.
+
+**condSnippet**
+
+The condition determining which expression gets resolved.
+
+**ifSnippet**
+
+The expression to resolve to if the condition is true.
+
+**elseSnippet**
+
+The expression to resolve to if the condition is false.
+
+**Overrides:** [NodeBuilder#getTernary](NodeBuilder.html#getTernary)
+
+**Returns:** The resolved method name.
+
+### .getTransforms( shaderStage : string ) : string
+
+Returns the transforms of the given shader stage as a GLSL string.
+
+**shaderStage**
+
+The shader stage.
+
+**Returns:** The GLSL snippet that defines the transforms.
+
+### .getTypeFromAttribute( attribute : BufferAttribute ) : string
+
+Returns the type for a given buffer attribute.
+
+**attribute**
+
+The buffer attribute.
+
+**Overrides:** [NodeBuilder#getTypeFromAttribute](NodeBuilder.html#getTypeFromAttribute)
+
+**Returns:** The type.
+
+### .getUniformFromNode( node : UniformNode, type : string, shaderStage : string, name : string ) : NodeUniform
+
+This method is one of the more important ones since it's responsible for generating a matching binding instance for the given uniform node.
+
+These bindings are later used in the renderer to create bind groups and layouts.
+
+**node**
+
+The uniform node.
+
+**type**
+
+The node data type.
+
+**shaderStage**
+
+The shader stage.
+
+**name**
+
+An optional uniform name.
+
+Default is `null`.
+
+**Overrides:** [NodeBuilder#getUniformFromNode](NodeBuilder.html#getUniformFromNode)
+
+**Returns:** The node uniform object.
+
+### .getUniforms( shaderStage : string ) : string
+
+Returns the uniforms of the given shader stage as a GLSL string.
+
+**shaderStage**
+
+The shader stage.
+
+**Overrides:** [NodeBuilder#getUniforms](NodeBuilder.html#getUniforms)
+
+**Returns:** The GLSL snippet that defines the uniforms.
+
+### .getVars( shaderStage : string ) : string
+
+Returns the variables of the given shader stage as a GLSL string.
+
+**shaderStage**
+
+The shader stage.
+
+**Overrides:** [NodeBuilder#getVars](NodeBuilder.html#getVars)
+
+**Returns:** The GLSL snippet that defines the variables.
+
+### .getVaryings( shaderStage : string ) : string
+
+Returns the varyings of the given shader stage as a GLSL string.
+
+**shaderStage**
+
+The shader stage.
+
+**Overrides:** [NodeBuilder#getVaryings](NodeBuilder.html#getVaryings)
+
+**Returns:** The GLSL snippet that defines the varyings.
+
+### .getVertexIndex() : string
+
+Returns the vertex index builtin.
+
+**Overrides:** [NodeBuilder#getVertexIndex](NodeBuilder.html#getVertexIndex)
+
+**Returns:** The vertex index.
+
+### .isAvailable( name : string ) : boolean
+
+Whether the requested feature is available or not.
+
+**name**
+
+The requested feature.
+
+**Overrides:** [NodeBuilder#isAvailable](NodeBuilder.html#isAvailable)
+
+**Returns:** Whether the requested feature is supported or not.
+
+### .isFlipY() : boolean
+
+Whether to flip texture data along its vertical axis or not.
+
+**Overrides:** [NodeBuilder#isFlipY](NodeBuilder.html#isFlipY)
+
+**Returns:** Returns always `true` in context of GLSL.
+
+### .needsToWorkingColorSpace( texture : Texture ) : boolean
+
+Checks if the given texture requires a manual conversion to the working color space.
+
+**texture**
+
+The texture to check.
+
+**Overrides:** [NodeBuilder#needsToWorkingColorSpace](NodeBuilder.html#needsToWorkingColorSpace)
+
+**Returns:** Whether the given texture requires a conversion to working color space or not.
+
+### .registerTransform( varyingName : string, attributeNode : AttributeNode )
+
+Registers a transform in context of Transform Feedback.
+
+**varyingName**
+
+The varying name.
+
+**attributeNode**
+
+The attribute node.
+
+### .setupPBO( storageBufferNode : StorageBufferNode )
+
+Setups the Pixel Buffer Object (PBO) for the given storage buffer node.
+
+**storageBufferNode**
+
+The storage buffer node.
+
+## Source
+
+[src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js](https://github.com/mrdoob/three.js/blob/master/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js)
\ No newline at end of file
diff --git a/docs/pages/GLSLNodeFunction.html.md b/docs/pages/GLSLNodeFunction.html.md
new file mode 100644
index 00000000000000..38bdf98a93a74a
--- /dev/null
+++ b/docs/pages/GLSLNodeFunction.html.md
@@ -0,0 +1,35 @@
+*Inheritance: NodeFunction →*
+
+# GLSLNodeFunction
+
+This class represents a GLSL node function.
+
+## Constructor
+
+### new GLSLNodeFunction( source : string )
+
+Constructs a new GLSL node function.
+
+**source**
+
+The GLSL source.
+
+## Methods
+
+### .getCode( name : string ) : string
+
+This method returns the GLSL code of the node function.
+
+**name**
+
+The function's name.
+
+Default is `this.name`.
+
+**Overrides:** [NodeFunction#getCode](NodeFunction.html#getCode)
+
+**Returns:** The shader code.
+
+## Source
+
+[src/nodes/parsers/GLSLNodeFunction.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/parsers/GLSLNodeFunction.js)
\ No newline at end of file
diff --git a/docs/pages/GLSLNodeParser.html.md b/docs/pages/GLSLNodeParser.html.md
new file mode 100644
index 00000000000000..448855b329ade8
--- /dev/null
+++ b/docs/pages/GLSLNodeParser.html.md
@@ -0,0 +1,27 @@
+*Inheritance: NodeParser →*
+
+# GLSLNodeParser
+
+A GLSL node parser.
+
+## Constructor
+
+### new GLSLNodeParser()
+
+## Methods
+
+### .parseFunction( source : string ) : GLSLNodeFunction
+
+The method parses the given GLSL code an returns a node function.
+
+**source**
+
+The GLSL code.
+
+**Overrides:** [NodeParser#parseFunction](NodeParser.html#parseFunction)
+
+**Returns:** A node function.
+
+## Source
+
+[src/nodes/parsers/GLSLNodeParser.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/parsers/GLSLNodeParser.js)
\ No newline at end of file
diff --git a/docs/pages/GLTFExporter.html.md b/docs/pages/GLTFExporter.html.md
new file mode 100644
index 00000000000000..ea80c0a3e967ab
--- /dev/null
+++ b/docs/pages/GLTFExporter.html.md
@@ -0,0 +1,192 @@
+# GLTFExporter
+
+An exporter for `glTF` 2.0.
+
+glTF (GL Transmission Format) is an [open format specification](https://github.com/KhronosGroup/glTF/tree/master/specification/2.0) for efficient delivery and loading of 3D content. Assets may be provided either in JSON (.gltf) or binary (.glb) format. External files store textures (.jpg, .png) and additional binary data (.bin). A glTF asset may deliver one or more scenes, including meshes, materials, textures, skins, skeletons, morph targets, animations, lights, and/or cameras.
+
+GLTFExporter supports the [glTF 2.0 extensions](https://github.com/KhronosGroup/glTF/tree/master/extensions/):
+
+* KHR\_lights\_punctual
+* KHR\_materials\_clearcoat
+* KHR\_materials\_dispersion
+* KHR\_materials\_emissive\_strength
+* KHR\_materials\_ior
+* KHR\_materials\_iridescence
+* KHR\_materials\_specular
+* KHR\_materials\_sheen
+* KHR\_materials\_transmission
+* KHR\_materials\_unlit
+* KHR\_materials\_volume
+* KHR\_mesh\_quantization
+* KHR\_texture\_transform
+* EXT\_materials\_bump
+* EXT\_mesh\_gpu\_instancing
+
+The following glTF 2.0 extension is supported by an external user plugin:
+
+* [KHR\_materials\_variants](https://github.com/takahirox/three-gltf-extensions)
+
+## Code Example
+
+```js
+const exporter = new GLTFExporter();
+const data = await exporter.parseAsync( scene, options );
+```
+
+## Import
+
+GLTFExporter is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { GLTFExporter } from 'three/addons/exporters/GLTFExporter.js';
+```
+
+## Constructor
+
+### new GLTFExporter()
+
+Constructs a new glTF exporter.
+
+## Properties
+
+### .textureUtils : WebGLTextureUtils | WebGPUTextureUtils
+
+A reference to a texture utils module.
+
+Default is `null`.
+
+## Methods
+
+### .parse( input : Scene | Array., onDone : GLTFExporter~OnDone, onError : GLTFExporter~OnError, options : GLTFExporter~Options )
+
+Parses the given scenes and generates the glTF output.
+
+**input**
+
+A scene or an array of scenes.
+
+**onDone**
+
+A callback function that is executed when the export has finished.
+
+**onError**
+
+A callback function that is executed when an error happens.
+
+**options**
+
+options
+
+### .parseAsync( input : Scene | Array., options : GLTFExporter~Options ) : Promise.<(ArrayBuffer|string)>
+
+Async version of [GLTFExporter#parse](GLTFExporter.html#parse).
+
+**input**
+
+A scene or an array of scenes.
+
+**options**
+
+options.
+
+**Returns:** A Promise that resolved with the exported glTF data.
+
+### .register( callback : function ) : GLTFExporter
+
+Registers a plugin callback. This API is internally used to implement the various glTF extensions but can also used by third-party code to add additional logic to the exporter.
+
+**callback**
+
+The callback function to register.
+
+**Returns:** A reference to this exporter.
+
+### .setTextureUtils( utils : WebGLTextureUtils | WebGPUTextureUtils ) : GLTFExporter
+
+Sets the texture utils for this exporter. Only relevant when compressed textures have to be exported.
+
+Depending on whether you use [WebGLRenderer](WebGLRenderer.html) or [WebGPURenderer](WebGPURenderer.html), you must inject the corresponding texture utils [WebGLTextureUtils](WebGLTextureUtils.html) or [WebGPUTextureUtils](WebGPUTextureUtils.html).
+
+**utils**
+
+The texture utils.
+
+**Returns:** A reference to this exporter.
+
+### .unregister( callback : function ) : GLTFExporter
+
+Unregisters a plugin callback.
+
+**callback**
+
+The callback function to unregister.
+
+**Returns:** A reference to this exporter.
+
+## Type Definitions
+
+### .OnDone( result : ArrayBuffer | string )
+
+onDone callback of `GLTFExporter`.
+
+**result**
+
+The generated .gltf (JSON) or .glb (binary).
+
+### .OnError( error : Error )
+
+onError callback of `GLTFExporter`.
+
+**error**
+
+The error object.
+
+### .Options
+
+Export options of `GLTFExporter`.
+
+**trs**
+boolean
+
+Export position, rotation and scale instead of matrix per node.
+
+Default is `false`.
+
+**onlyVisible**
+boolean
+
+Export only visible 3D objects.
+
+Default is `true`.
+
+**binary**
+boolean
+
+Export in binary (.glb) format, returning an ArrayBuffer.
+
+Default is `false`.
+
+**maxTextureSize**
+number
+
+Restricts the image maximum size (both width and height) to the given value.
+
+Default is `Infinity`.
+
+**animations**
+Array.<[AnimationClip](AnimationClip.html)\>
+
+List of animations to be included in the export.
+
+Default is `[]`.
+
+**includeCustomExtensions**
+boolean
+
+Export custom glTF extensions defined on an object's `userData.gltfExtensions` property.
+
+Default is `false`.
+
+## Source
+
+[examples/jsm/exporters/GLTFExporter.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/exporters/GLTFExporter.js)
\ No newline at end of file
diff --git a/docs/pages/GLTFLoader.html.md b/docs/pages/GLTFLoader.html.md
new file mode 100644
index 00000000000000..4f5ed7945d9a01
--- /dev/null
+++ b/docs/pages/GLTFLoader.html.md
@@ -0,0 +1,218 @@
+*Inheritance: Loader →*
+
+# GLTFLoader
+
+A loader for the glTF 2.0 format.
+
+\[glTF\](https://www.khronos.org/gltf/} (GL Transmission Format) is an [open format specification](https://github.com/KhronosGroup/glTF/tree/main/specification/2.0\)) whenever possible. Be advised that image bitmaps are not automatically GC-collected when they are no longer referenced, and they require special handling during the disposal process.
+
+`GLTFLoader` supports the following glTF 2.0 extensions:
+
+* KHR\_draco\_mesh\_compression
+* KHR\_materials\_clearcoat
+* KHR\_materials\_dispersion
+* KHR\_materials\_ior
+* KHR\_materials\_specular
+* KHR\_materials\_transmission
+* KHR\_materials\_iridescence
+* KHR\_materials\_unlit
+* KHR\_materials\_volume
+* KHR\_mesh\_quantization
+* KHR\_lights\_punctual
+* KHR\_texture\_basisu
+* KHR\_texture\_transform
+* EXT\_texture\_webp
+* EXT\_meshopt\_compression
+* EXT\_mesh\_gpu\_instancing
+
+The following glTF 2.0 extension is supported by an external user plugin:
+
+* [KHR\_materials\_variants](https://github.com/takahirox/three-gltf-extensions)
+* [MSFT\_texture\_dds](https://github.com/takahirox/three-gltf-extensions)
+* [KHR\_animation\_pointer](https://github.com/needle-tools/three-animation-pointer)
+* [NEEDLE\_progressive](https://github.com/needle-tools/gltf-progressive)
+
+## Code Example
+
+```js
+const loader = new GLTFLoader();
+// Optional: Provide a DRACOLoader instance to decode compressed mesh data
+const dracoLoader = new DRACOLoader();
+dracoLoader.setDecoderPath( '/examples/jsm/libs/draco/' );
+loader.setDRACOLoader( dracoLoader );
+const gltf = await loader.loadAsync( 'models/gltf/duck/duck.gltf' );
+scene.add( gltf.scene );
+```
+
+## Import
+
+GLTFLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+```
+
+## Constructor
+
+### new GLTFLoader( manager : LoadingManager )
+
+Constructs a new glTF loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded glTF asset to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( data : string | ArrayBuffer, path : string, onLoad : function, onError : onErrorCallback )
+
+Parses the given FBX data and returns the resulting group.
+
+**data**
+
+The raw glTF data.
+
+**path**
+
+The URL base path.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+### .parseAsync( data : string | ArrayBuffer, path : string ) : Promise. (async)
+
+Async version of [GLTFLoader#parse](GLTFLoader.html#parse).
+
+**data**
+
+The raw glTF data.
+
+**path**
+
+The URL base path.
+
+**Returns:** A Promise that resolves with the loaded glTF when the parsing has been finished.
+
+### .register( callback : function ) : GLTFLoader
+
+Registers a plugin callback. This API is internally used to implement the various glTF extensions but can also used by third-party code to add additional logic to the loader.
+
+**callback**
+
+The callback function to register.
+
+**Returns:** A reference to this loader.
+
+### .setDRACOLoader( dracoLoader : DRACOLoader ) : GLTFLoader
+
+Sets the given Draco loader to this loader. Required for decoding assets compressed with the `KHR_draco_mesh_compression` extension.
+
+**dracoLoader**
+
+The Draco loader to set.
+
+**Returns:** A reference to this loader.
+
+### .setKTX2Loader( ktx2Loader : KTX2Loader ) : GLTFLoader
+
+Sets the given KTX2 loader to this loader. Required for loading KTX2 compressed textures.
+
+**ktx2Loader**
+
+The KTX2 loader to set.
+
+**Returns:** A reference to this loader.
+
+### .setMeshoptDecoder( meshoptDecoder : Object ) : GLTFLoader
+
+Sets the given meshopt decoder. Required for decoding assets compressed with the `EXT_meshopt_compression` extension.
+
+**meshoptDecoder**
+
+The meshopt decoder to set.
+
+**Returns:** A reference to this loader.
+
+### .unregister( callback : function ) : GLTFLoader
+
+Unregisters a plugin callback.
+
+**callback**
+
+The callback function to unregister.
+
+**Returns:** A reference to this loader.
+
+## Type Definitions
+
+### .LoadObject
+
+Loader result of `GLTFLoader`.
+
+**animations**
+Array.<[AnimationClip](AnimationClip.html)\>
+
+An array of animation clips.
+
+**asset**
+Object
+
+Meta data about the loaded asset.
+
+**cameras**
+Array.<[Camera](Camera.html)\>
+
+An array of cameras.
+
+**parser**
+GLTFParser
+
+A reference to the internal parser.
+
+**scene**
+[Group](Group.html)
+
+The default scene.
+
+**scenes**
+Array.<[Group](Group.html)\>
+
+glTF assets might define multiple scenes.
+
+**userData**
+Object
+
+Additional data.
+
+## Source
+
+[examples/jsm/loaders/GLTFLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/GLTFLoader.js)
\ No newline at end of file
diff --git a/docs/pages/GPUComputationRenderer.html.md b/docs/pages/GPUComputationRenderer.html.md
new file mode 100644
index 00000000000000..596b70ab93a1c8
--- /dev/null
+++ b/docs/pages/GPUComputationRenderer.html.md
@@ -0,0 +1,243 @@
+# GPUComputationRenderer
+
+GPUComputationRenderer, based on SimulationRenderer by @zz85.
+
+The GPUComputationRenderer uses the concept of variables. These variables are RGBA float textures that hold 4 floats for each compute element (texel).
+
+Each variable has a fragment shader that defines the computation made to obtain the variable in question. You can use as many variables you need, and make dependencies so you can use textures of other variables in the shader (the sampler uniforms are added automatically) Most of the variables will need themselves as dependency.
+
+The renderer has actually two render targets per variable, to make ping-pong. Textures from the current frame are used as inputs to render the textures of the next frame.
+
+The render targets of the variables can be used as input textures for your visualization shaders.
+
+Variable names should be valid identifiers and should not collide with THREE GLSL used identifiers. a common approach could be to use 'texture' prefixing the variable name; i.e texturePosition, textureVelocity...
+
+The size of the computation (sizeX \* sizeY) is defined as 'resolution' automatically in the shader. For example:
+
+Basic use:
+
+```js
+// Initialization...
+// Create computation renderer
+const gpuCompute = new GPUComputationRenderer( 1024, 1024, renderer );
+// Create initial state float textures
+const pos0 = gpuCompute.createTexture();
+const vel0 = gpuCompute.createTexture();
+// and fill in here the texture data...
+// Add texture variables
+const velVar = gpuCompute.addVariable( "textureVelocity", fragmentShaderVel, vel0 );
+const posVar = gpuCompute.addVariable( "texturePosition", fragmentShaderPos, pos0 );
+// Add variable dependencies
+gpuCompute.setVariableDependencies( velVar, [ velVar, posVar ] );
+gpuCompute.setVariableDependencies( posVar, [ velVar, posVar ] );
+// Add custom uniforms
+velVar.material.uniforms.time = { value: 0.0 };
+// Check for completeness
+const error = gpuCompute.init();
+if ( error !== null ) {
+ console.error( error );
+}
+// In each frame...
+// Compute!
+gpuCompute.compute();
+// Update texture uniforms in your visualization materials with the gpu renderer output
+myMaterial.uniforms.myTexture.value = gpuCompute.getCurrentRenderTarget( posVar ).texture;
+// Do your rendering
+renderer.render( myScene, myCamera );
+```
+
+Also, you can use utility functions to create ShaderMaterial and perform computations (rendering between textures) Note that the shaders can have multiple input textures.
+
+```js
+const myFilter1 = gpuCompute.createShaderMaterial( myFilterFragmentShader1, { theTexture: { value: null } } );
+const myFilter2 = gpuCompute.createShaderMaterial( myFilterFragmentShader2, { theTexture: { value: null } } );
+const inputTexture = gpuCompute.createTexture();
+// Fill in here inputTexture...
+myFilter1.uniforms.theTexture.value = inputTexture;
+const myRenderTarget = gpuCompute.createRenderTarget();
+myFilter2.uniforms.theTexture.value = myRenderTarget.texture;
+const outputRenderTarget = gpuCompute.createRenderTarget();
+// Now use the output texture where you want:
+myMaterial.uniforms.map.value = outputRenderTarget.texture;
+// And compute each frame, before rendering to screen:
+gpuCompute.doRenderTarget( myFilter1, myRenderTarget );
+gpuCompute.doRenderTarget( myFilter2, outputRenderTarget );
+```
+
+## Code Example
+
+```js
+#DEFINE resolution vec2( 1024.0, 1024.0 )
+```
+
+## Import
+
+GPUComputationRenderer is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { GPUComputationRenderer } from 'three/addons/misc/GPUComputationRenderer.js';
+```
+
+## Constructor
+
+### new GPUComputationRenderer( sizeX : number, sizeY : number, renderer : WebGLRenderer )
+
+Constructs a new GPU computation renderer.
+
+**sizeX**
+
+Computation problem size is always 2d: sizeX \* sizeY elements.
+
+**sizeY**
+
+Computation problem size is always 2d: sizeX \* sizeY elements.
+
+**renderer**
+
+The renderer.
+
+## Properties
+
+### .addResolutionDefine
+
+Adds a resolution defined for the given material shader.
+
+## Methods
+
+### .addVariable( variableName : string, computeFragmentShader : string, initialValueTexture : Texture ) : Object
+
+Adds a compute variable to the renderer.
+
+**variableName**
+
+The variable name.
+
+**computeFragmentShader**
+
+The compute (fragment) shader source.
+
+**initialValueTexture**
+
+The initial value texture.
+
+**Returns:** The compute variable.
+
+### .compute()
+
+Executes the compute. This method is usually called in the animation loop.
+
+### .createRenderTarget( sizeXTexture : number, sizeYTexture : number, wrapS : number, wrapT : number, minFilter : number, magFilter : number ) : WebGLRenderTarget
+
+Creates a new render target from the given parameters.
+
+**sizeXTexture**
+
+The width of the render target.
+
+**sizeYTexture**
+
+The height of the render target.
+
+**wrapS**
+
+The wrapS value.
+
+**wrapT**
+
+The wrapS value.
+
+**minFilter**
+
+The minFilter value.
+
+**magFilter**
+
+The magFilter value.
+
+**Returns:** The new render target.
+
+### .createTexture() : DataTexture
+
+Creates a new data texture.
+
+**Returns:** The new data texture.
+
+### .dispose()
+
+Frees all internal resources. Call this method if you don't need the renderer anymore.
+
+### .doRenderTarget( material : Material, output : WebGLRenderTarget )
+
+Renders the given material into the given render target with a full-screen pass.
+
+**material**
+
+The material.
+
+**output**
+
+The output.
+
+### .getAlternateRenderTarget( variable : Object ) : WebGLRenderTarget
+
+Returns the alternate render target for the given compute variable.
+
+**variable**
+
+The compute variable.
+
+**Returns:** The alternate render target.
+
+### .getCurrentRenderTarget( variable : Object ) : WebGLRenderTarget
+
+Returns the current render target for the given compute variable.
+
+**variable**
+
+The compute variable.
+
+**Returns:** The current render target.
+
+### .init() : string
+
+Initializes the renderer.
+
+**Returns:** Returns `null` if no errors are detected. Otherwise returns the error message.
+
+### .renderTexture( input : Texture, output : WebGLRenderTarget )
+
+Renders the given texture into the given render target.
+
+**input**
+
+The input.
+
+**output**
+
+The output.
+
+### .setDataType( type : FloatType | HalfFloatType ) : GPUComputationRenderer
+
+Sets the data type of the internal textures.
+
+**type**
+
+The type to set.
+
+**Returns:** A reference to this renderer.
+
+### .setVariableDependencies( variable : Object, dependencies : Array. )
+
+Sets variable dependencies.
+
+**variable**
+
+The compute variable.
+
+**dependencies**
+
+Other compute variables that represents the dependencies.
+
+## Source
+
+[examples/jsm/misc/GPUComputationRenderer.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/misc/GPUComputationRenderer.js)
\ No newline at end of file
diff --git a/docs/pages/GTAONode.html.md b/docs/pages/GTAONode.html.md
new file mode 100644
index 00000000000000..dcd757c81398a9
--- /dev/null
+++ b/docs/pages/GTAONode.html.md
@@ -0,0 +1,159 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# GTAONode
+
+Post processing node for applying Ground Truth Ambient Occlusion (GTAO) to a scene.
+
+Reference: [Practical Real-Time Strategies for Accurate Indirect Occlusion](https://www.activision.com/cdn/research/Practical_Real_Time_Strategies_for_Accurate_Indirect_Occlusion_NEW%20VERSION_COLOR.pdf).
+
+## Code Example
+
+```js
+const postProcessing = new THREE.PostProcessing( renderer );
+const scenePass = pass( scene, camera );
+scenePass.setMRT( mrt( {
+ output: output,
+ normal: normalView
+} ) );
+const scenePassColor = scenePass.getTextureNode( 'output' );
+const scenePassNormal = scenePass.getTextureNode( 'normal' );
+const scenePassDepth = scenePass.getTextureNode( 'depth' );
+const aoPass = ao( scenePassDepth, scenePassNormal, camera );
+postProcessing.outputNod = aoPass.getTextureNode().mul( scenePassColor );
+```
+
+## Import
+
+GTAONode is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { ao } from 'three/addons/tsl/display/GTAONode.js';
+```
+
+## Constructor
+
+### new GTAONode( depthNode : Node., normalNode : Node., camera : Camera )
+
+Constructs a new GTAO node.
+
+**depthNode**
+
+A node that represents the scene's depth.
+
+**normalNode**
+
+A node that represents the scene's normals.
+
+**camera**
+
+The camera the scene is rendered with.
+
+## Properties
+
+### .depthNode : Node.
+
+A node that represents the scene's depth.
+
+### .distanceExponent : UniformNode.
+
+Another option to tweak the occlusion. The recommended range is `[1,2]` for attenuating the AO.
+
+### .distanceFallOff : UniformNode.
+
+The distance fall off value of the ambient occlusion. A lower value leads to a larger AO effect. The value should lie in the range `[0,1]`.
+
+### .normalNode : Node.
+
+A node that represents the scene's normals. If no normals are passed to the constructor (because MRT is not available), normals can be automatically reconstructed from depth values in the shader.
+
+### .radius : UniformNode.
+
+The radius of the ambient occlusion.
+
+### .resolution : UniformNode.
+
+The resolution of the effect. Can be scaled via `resolutionScale`.
+
+### .resolutionScale : number
+
+The resolution scale. By default the effect is rendered in full resolution for best quality but a value of `0.5` should be sufficient for most scenes.
+
+Default is `1`.
+
+### .samples : UniformNode.
+
+How many samples are used to compute the AO. A higher value results in better quality but also in a more expensive runtime behavior.
+
+### .scale : UniformNode.
+
+The scale of the ambient occlusion.
+
+### .thickness : UniformNode.
+
+The thickness of the ambient occlusion.
+
+### .updateBeforeType : string
+
+The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node renders its effect once per frame in `updateBefore()`.
+
+Default is `'frame'`.
+
+**Overrides:** [TempNode#updateBeforeType](TempNode.html#updateBeforeType)
+
+### .useTemporalFiltering : boolean
+
+Whether to use temporal filtering or not. Setting this property to `true` requires the usage of `TRAANode`. This will help to reduce noise although it introduces typical TAA artifacts like ghosting and temporal instabilities.
+
+If setting this property to `false`, a manual denoise via `DenoiseNode` might be required.
+
+Default is `false`.
+
+## Methods
+
+### .dispose()
+
+Frees internal resources. This method should be called when the effect is no longer required.
+
+**Overrides:** [TempNode#dispose](TempNode.html#dispose)
+
+### .getTextureNode() : PassTextureNode
+
+Returns the result of the effect as a texture node.
+
+**Returns:** A texture node that represents the result of the effect.
+
+### .setSize( width : number, height : number )
+
+Sets the size of the effect.
+
+**width**
+
+The width of the effect.
+
+**height**
+
+The height of the effect.
+
+### .setup( builder : NodeBuilder ) : PassTextureNode
+
+This method is used to setup the effect's TSL code.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#setup](TempNode.html#setup)
+
+### .updateBefore( frame : NodeFrame )
+
+This method is used to render the effect once per frame.
+
+**frame**
+
+The current node frame.
+
+**Overrides:** [TempNode#updateBefore](TempNode.html#updateBefore)
+
+## Source
+
+[examples/jsm/tsl/display/GTAONode.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/tsl/display/GTAONode.js)
\ No newline at end of file
diff --git a/docs/pages/GTAOPass.html.md b/docs/pages/GTAOPass.html.md
new file mode 100644
index 00000000000000..1cf6cbfeb3ff96
--- /dev/null
+++ b/docs/pages/GTAOPass.html.md
@@ -0,0 +1,213 @@
+*Inheritance: Pass →*
+
+# GTAOPass
+
+A pass for an GTAO effect.
+
+`GTAOPass` provides better quality than [SSAOPass](SSAOPass.html) but is also more expensive.
+
+## Code Example
+
+```js
+const gtaoPass = new GTAOPass( scene, camera, width, height );
+gtaoPass.output = GTAOPass.OUTPUT.Denoise;
+composer.addPass( gtaoPass );
+```
+
+## Import
+
+GTAOPass is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { GTAOPass } from 'three/addons/postprocessing/GTAOPass.js';
+```
+
+## Constructor
+
+### new GTAOPass( scene : Scene, camera : Camera, width : number, height : number, parameters : Object, aoParameters : Object, pdParameters : Object )
+
+Constructs a new GTAO pass.
+
+**scene**
+
+The scene to compute the AO for.
+
+**camera**
+
+The camera.
+
+**width**
+
+The width of the effect.
+
+Default is `512`.
+
+**height**
+
+The height of the effect.
+
+Default is `512`.
+
+**parameters**
+
+The pass parameters.
+
+**aoParameters**
+
+The AO parameters.
+
+**pdParameters**
+
+The denoise parameters.
+
+## Properties
+
+### .blendIntensity : number
+
+The AO blend intensity.
+
+Default is `1`.
+
+### .camera : Camera
+
+The camera.
+
+### .clear : boolean
+
+Overwritten to perform a clear operation by default.
+
+Default is `true`.
+
+**Overrides:** [Pass#clear](Pass.html#clear)
+
+### .gtaoMap : Texture (readonly)
+
+A texture holding the computed AO.
+
+### .height : number
+
+The height of the effect.
+
+Default is `512`.
+
+### .output : number
+
+The output configuration.
+
+Default is `0`.
+
+### .pdRadiusExponent : number
+
+The Poisson Denoise radius exponent.
+
+Default is `2`.
+
+### .pdRings : number
+
+The number of Poisson Denoise rings.
+
+Default is `2`.
+
+### .pdSamples : number
+
+The Poisson Denoise sample count.
+
+Default is `16`.
+
+### .scene : Scene
+
+The scene to render the AO for.
+
+### .width : number
+
+The width of the effect.
+
+Default is `512`.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever the pass is no longer used in your app.
+
+**Overrides:** [Pass#dispose](Pass.html#dispose)
+
+### .render( renderer : WebGLRenderer, writeBuffer : WebGLRenderTarget, readBuffer : WebGLRenderTarget, deltaTime : number, maskActive : boolean )
+
+Performs the GTAO pass.
+
+**renderer**
+
+The renderer.
+
+**writeBuffer**
+
+The write buffer. This buffer is intended as the rendering destination for the pass.
+
+**readBuffer**
+
+The read buffer. The pass can access the result from the previous pass from this buffer.
+
+**deltaTime**
+
+The delta time in seconds.
+
+**maskActive**
+
+Whether masking is active or not.
+
+**Overrides:** [Pass#render](Pass.html#render)
+
+### .setGBuffer( depthTexture : DepthTexture, normalTexture : DepthTexture )
+
+Configures the GBuffer of this pass. If no arguments are passed, the pass creates an internal render target for holding depth and normal data.
+
+**depthTexture**
+
+The depth texture.
+
+**normalTexture**
+
+The normal texture.
+
+### .setSceneClipBox( box : Box3 )
+
+Configures the clip box of the GTAO shader with the given AABB.
+
+**box**
+
+The AABB enclosing the scene that should receive AO. When passing `null`, to clip box is used.
+
+### .setSize( width : number, height : number )
+
+Sets the size of the pass.
+
+**width**
+
+The width to set.
+
+**height**
+
+The height to set.
+
+**Overrides:** [Pass#setSize](Pass.html#setSize)
+
+### .updateGtaoMaterial( parameters : Object )
+
+Updates the GTAO material from the given parameter object.
+
+**parameters**
+
+The GTAO material parameters.
+
+### .updatePdMaterial( parameters : Object )
+
+Updates the Denoise material from the given parameter object.
+
+**parameters**
+
+The denoise parameters.
+
+## Source
+
+[examples/jsm/postprocessing/GTAOPass.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/GTAOPass.js)
\ No newline at end of file
diff --git a/docs/pages/GaussianBlurNode.html.md b/docs/pages/GaussianBlurNode.html.md
new file mode 100644
index 00000000000000..3778612840dbc1
--- /dev/null
+++ b/docs/pages/GaussianBlurNode.html.md
@@ -0,0 +1,145 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# GaussianBlurNode
+
+Post processing node for creating a gaussian blur effect.
+
+## Import
+
+GaussianBlurNode is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { gaussianBlur, premultipliedGaussianBlur } from 'three/addons/tsl/display/GaussianBlurNode.js';
+```
+
+## Constructor
+
+### new GaussianBlurNode( textureNode : TextureNode, directionNode : Node.<(vec2|float)>, sigma : number, options : Object )
+
+Constructs a new gaussian blur node.
+
+**textureNode**
+
+The texture node that represents the input of the effect.
+
+**directionNode**
+
+Defines the direction and radius of the blur.
+
+Default is `null`.
+
+**sigma**
+
+Controls the kernel of the blur filter. Higher values mean a wider blur radius.
+
+Default is `4`.
+
+**options**
+
+Additional options for the gaussian blur effect.
+
+Default is `{}`.
+
+**premultipliedAlpha**
+
+Whether to use premultiplied alpha for the blur effect.
+
+Default is `false`.
+
+**resolutionScale**
+
+The resolution of the effect. 0.5 means half the resolution of the texture node.
+
+Default is `1`.
+
+## Properties
+
+### .directionNode : Node.<(vec2|float)>
+
+Defines the direction and radius of the blur.
+
+### .premultipliedAlpha : boolean
+
+Whether the effect should use premultiplied alpha or not. Set this to `true` if you are going to blur texture input with transparency.
+
+Default is `false`.
+
+### .resolution : Vector2
+
+The resolution scale.
+
+Default is `{(1,1)}`.
+
+**Deprecated:** Yes
+
+### .resolutionScale : number
+
+The resolution scale.
+
+Default is `(1)`.
+
+### .sigma : number
+
+Controls the kernel of the blur filter. Higher values mean a wider blur radius.
+
+### .textureNode : TextureNode
+
+The texture node that represents the input of the effect.
+
+### .updateBeforeType : string
+
+The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node renders its effect once per frame in `updateBefore()`.
+
+Default is `'frame'`.
+
+**Overrides:** [TempNode#updateBeforeType](TempNode.html#updateBeforeType)
+
+## Methods
+
+### .dispose()
+
+Frees internal resources. This method should be called when the effect is no longer required.
+
+**Overrides:** [TempNode#dispose](TempNode.html#dispose)
+
+### .getTextureNode() : PassTextureNode
+
+Returns the result of the effect as a texture node.
+
+**Returns:** A texture node that represents the result of the effect.
+
+### .setSize( width : number, height : number )
+
+Sets the size of the effect.
+
+**width**
+
+The width of the effect.
+
+**height**
+
+The height of the effect.
+
+### .setup( builder : NodeBuilder ) : PassTextureNode
+
+This method is used to setup the effect's TSL code.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#setup](TempNode.html#setup)
+
+### .updateBefore( frame : NodeFrame )
+
+This method is used to render the effect once per frame.
+
+**frame**
+
+The current node frame.
+
+**Overrides:** [TempNode#updateBefore](TempNode.html#updateBefore)
+
+## Source
+
+[examples/jsm/tsl/display/GaussianBlurNode.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/tsl/display/GaussianBlurNode.js)
\ No newline at end of file
diff --git a/docs/pages/GlitchPass.html.md b/docs/pages/GlitchPass.html.md
new file mode 100644
index 00000000000000..c1be4fbaabc55e
--- /dev/null
+++ b/docs/pages/GlitchPass.html.md
@@ -0,0 +1,86 @@
+*Inheritance: Pass →*
+
+# GlitchPass
+
+Pass for creating a glitch effect.
+
+## Code Example
+
+```js
+const glitchPass = new GlitchPass();
+composer.addPass( glitchPass );
+```
+
+## Import
+
+GlitchPass is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { GlitchPass } from 'three/addons/postprocessing/GlitchPass.js';
+```
+
+## Constructor
+
+### new GlitchPass( dt_size : number )
+
+Constructs a new glitch pass.
+
+**dt\_size**
+
+The size of the displacement texture for digital glitch squares.
+
+Default is `64`.
+
+## Properties
+
+### .goWild : boolean
+
+Whether to noticeably increase the effect intensity or not.
+
+Default is `false`.
+
+### .material : ShaderMaterial
+
+The pass material.
+
+### .uniforms : Object
+
+The pass uniforms.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever the pass is no longer used in your app.
+
+**Overrides:** [Pass#dispose](Pass.html#dispose)
+
+### .render( renderer : WebGLRenderer, writeBuffer : WebGLRenderTarget, readBuffer : WebGLRenderTarget, deltaTime : number, maskActive : boolean )
+
+Performs the glitch pass.
+
+**renderer**
+
+The renderer.
+
+**writeBuffer**
+
+The write buffer. This buffer is intended as the rendering destination for the pass.
+
+**readBuffer**
+
+The read buffer. The pass can access the result from the previous pass from this buffer.
+
+**deltaTime**
+
+The delta time in seconds.
+
+**maskActive**
+
+Whether masking is active or not.
+
+**Overrides:** [Pass#render](Pass.html#render)
+
+## Source
+
+[examples/jsm/postprocessing/GlitchPass.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/GlitchPass.js)
\ No newline at end of file
diff --git a/docs/pages/GrannyKnot.html.md b/docs/pages/GrannyKnot.html.md
new file mode 100644
index 00000000000000..39bbed015da2ce
--- /dev/null
+++ b/docs/pages/GrannyKnot.html.md
@@ -0,0 +1,39 @@
+*Inheritance: Curve →*
+
+# GrannyKnot
+
+A Granny Knot curve.
+
+## Import
+
+GrannyKnot is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { GrannyKnot } from 'three/addons/curves/CurveExtras.js';
+```
+
+## Constructor
+
+### new GrannyKnot()
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector3 ) : Vector3
+
+This method returns a vector in 3D space for the given interpolation factor.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve.
+
+## Source
+
+[examples/jsm/curves/CurveExtras.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/curves/CurveExtras.js)
\ No newline at end of file
diff --git a/docs/pages/GridHelper.html.md b/docs/pages/GridHelper.html.md
new file mode 100644
index 00000000000000..be970461b431ef
--- /dev/null
+++ b/docs/pages/GridHelper.html.md
@@ -0,0 +1,54 @@
+*Inheritance: EventDispatcher → Object3D → Line → LineSegments →*
+
+# GridHelper
+
+The helper is an object to define grids. Grids are two-dimensional arrays of lines.
+
+## Code Example
+
+```js
+const size = 10;
+const divisions = 10;
+const gridHelper = new THREE.GridHelper( size, divisions );
+scene.add( gridHelper );
+```
+
+## Constructor
+
+### new GridHelper( size : number, divisions : number, color1 : number | Color | string, color2 : number | Color | string )
+
+Constructs a new grid helper.
+
+**size**
+
+The size of the grid.
+
+Default is `10`.
+
+**divisions**
+
+The number of divisions across the grid.
+
+Default is `10`.
+
+**color1**
+
+The color of the center line.
+
+Default is `0x444444`.
+
+**color2**
+
+The color of the lines of the grid.
+
+Default is `0x888888`.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+## Source
+
+[src/helpers/GridHelper.js](https://github.com/mrdoob/three.js/blob/master/src/helpers/GridHelper.js)
\ No newline at end of file
diff --git a/docs/pages/GroundedSkybox.html.md b/docs/pages/GroundedSkybox.html.md
new file mode 100644
index 00000000000000..a619fa8bea76d0
--- /dev/null
+++ b/docs/pages/GroundedSkybox.html.md
@@ -0,0 +1,52 @@
+*Inheritance: EventDispatcher → Object3D → Mesh →*
+
+# GroundedSkybox
+
+A ground-projected skybox.
+
+By default the object is centered at the camera, so it is often helpful to set `skybox.position.y = height` to put the ground at the origin.
+
+## Code Example
+
+```js
+const height = 15, radius = 100;
+const skybox = new GroundedSkybox( envMap, height, radius );
+skybox.position.y = height;
+scene.add( skybox );
+```
+
+## Import
+
+GroundedSkybox is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { GroundedSkybox } from 'three/addons/objects/GroundedSkybox.js';
+```
+
+## Constructor
+
+### new GroundedSkybox( map : Texture, height : number, radius : number, resolution : number )
+
+Constructs a new ground-projected skybox.
+
+**map**
+
+The environment map to use.
+
+**height**
+
+The height is how far the camera that took the photo was above the ground. A larger value will magnify the downward part of the image.
+
+**radius**
+
+The radius of the skybox. Must be large enough to ensure the scene's camera stays inside.
+
+**resolution**
+
+The geometry resolution of the skybox.
+
+Default is `128`.
+
+## Source
+
+[examples/jsm/objects/GroundedSkybox.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/objects/GroundedSkybox.js)
\ No newline at end of file
diff --git a/docs/pages/Group.html.md b/docs/pages/Group.html.md
new file mode 100644
index 00000000000000..fe4e575f18346e
--- /dev/null
+++ b/docs/pages/Group.html.md
@@ -0,0 +1,32 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# Group
+
+This is almost identical to an [Object3D](Object3D.html). Its purpose is to make working with groups of objects syntactically clearer.
+
+## Code Example
+
+```js
+// Create a group and add the two cubes.
+// These cubes can now be rotated / scaled etc as a group.
+const group = new THREE.Group();
+group.add( meshA );
+group.add( meshB );
+scene.add( group );
+```
+
+## Constructor
+
+### new Group()
+
+## Properties
+
+### .isGroup : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/objects/Group.js](https://github.com/mrdoob/three.js/blob/master/src/objects/Group.js)
\ No newline at end of file
diff --git a/docs/pages/Gyroscope.html.md b/docs/pages/Gyroscope.html.md
new file mode 100644
index 00000000000000..b37dcc6c0a3e7a
--- /dev/null
+++ b/docs/pages/Gyroscope.html.md
@@ -0,0 +1,23 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# Gyroscope
+
+A special type of 3D object that takes a position from the scene graph hierarchy but uses its local rotation as world rotation. It works like real-world gyroscope - you can move it around using hierarchy while its orientation stays fixed with respect to the world.
+
+## Import
+
+Gyroscope is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { Gyroscope } from 'three/addons/misc/Gyroscope.js';
+```
+
+## Constructor
+
+### new Gyroscope()
+
+Constructs a new gyroscope.
+
+## Source
+
+[examples/jsm/misc/Gyroscope.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/misc/Gyroscope.js)
\ No newline at end of file
diff --git a/docs/pages/HDRCubeTextureLoader.html.md b/docs/pages/HDRCubeTextureLoader.html.md
new file mode 100644
index 00000000000000..aee8ef1289fece
--- /dev/null
+++ b/docs/pages/HDRCubeTextureLoader.html.md
@@ -0,0 +1,85 @@
+*Inheritance: Loader →*
+
+# HDRCubeTextureLoader
+
+A loader for loading HDR cube textures.
+
+## Code Example
+
+```js
+const loader = new HDRCubeTextureLoader();
+loader.setPath( 'textures/cube/pisaHDR/' );
+const cubeTexture = await loader.loadAsync( [ 'px.hdr', 'nx.hdr', 'py.hdr', 'ny.hdr', 'pz.hdr', 'nz.hdr' ] );
+scene.background = cubeTexture;
+scene.environment = cubeTexture;
+```
+
+## Import
+
+HDRCubeTextureLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { HDRCubeTextureLoader } from 'three/addons/loaders/HDRCubeTextureLoader.js';
+```
+
+## Constructor
+
+### new HDRCubeTextureLoader( manager : LoadingManager )
+
+Constructs a new HDR cube texture loader.
+
+**manager**
+
+The loading manager.
+
+## Properties
+
+### .hdrLoader : HDRLoader
+
+The internal HDR loader that loads the individual textures for each cube face.
+
+### .type : HalfFloatType | FloatType
+
+The texture type.
+
+Default is `HalfFloatType`.
+
+## Methods
+
+### .load( urls : Array., onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback ) : CubeTexture
+
+Starts loading from the given URLs and passes the loaded HDR cube texture to the `onLoad()` callback.
+
+**urls**
+
+The paths/URLs of the files to be loaded. This can also be a data URIs.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+**Returns:** The HDR cube texture.
+
+### .setDataType( value : HalfFloatType | FloatType ) : HDRCubeTextureLoader
+
+Sets the texture type.
+
+**value**
+
+The texture type to set.
+
+**Returns:** A reference to this loader.
+
+## Source
+
+[examples/jsm/loaders/HDRCubeTextureLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/HDRCubeTextureLoader.js)
\ No newline at end of file
diff --git a/docs/pages/HDRLoader.html.md b/docs/pages/HDRLoader.html.md
new file mode 100644
index 00000000000000..849d2a6737f4f6
--- /dev/null
+++ b/docs/pages/HDRLoader.html.md
@@ -0,0 +1,68 @@
+*Inheritance: Loader → DataTextureLoader →*
+
+# HDRLoader
+
+A loader for the RGBE HDR texture format.
+
+## Code Example
+
+```js
+const loader = new HDRLoader();
+const envMap = await loader.loadAsync( 'textures/equirectangular/blouberg_sunrise_2_1k.hdr' );
+envMap.mapping = THREE.EquirectangularReflectionMapping;
+scene.environment = envMap;
+```
+
+## Import
+
+HDRLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { HDRLoader } from 'three/addons/loaders/HDRLoader.js';
+```
+
+## Constructor
+
+### new HDRLoader( manager : LoadingManager )
+
+Constructs a new RGBE/HDR loader.
+
+**manager**
+
+The loading manager.
+
+## Properties
+
+### .type : HalfFloatType | FloatType
+
+The texture type.
+
+Default is `HalfFloatType`.
+
+## Methods
+
+### .parse( buffer : ArrayBuffer ) : DataTextureLoader~TexData
+
+Parses the given RGBE texture data.
+
+**buffer**
+
+The raw texture data.
+
+**Overrides:** [DataTextureLoader#parse](DataTextureLoader.html#parse)
+
+**Returns:** An object representing the parsed texture data.
+
+### .setDataType( value : HalfFloatType | FloatType ) : HDRLoader
+
+Sets the texture type.
+
+**value**
+
+The texture type to set.
+
+**Returns:** A reference to this loader.
+
+## Source
+
+[examples/jsm/loaders/HDRLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/HDRLoader.js)
\ No newline at end of file
diff --git a/docs/pages/HTMLMesh.html.md b/docs/pages/HTMLMesh.html.md
new file mode 100644
index 00000000000000..8450df02e93bbb
--- /dev/null
+++ b/docs/pages/HTMLMesh.html.md
@@ -0,0 +1,43 @@
+*Inheritance: EventDispatcher → Object3D → Mesh →*
+
+# HTMLMesh
+
+This class can be used to render a DOM element onto a canvas and use it as a texture for a plane mesh.
+
+A typical use case for this class is to render the GUI of `lil-gui` as a texture so it is compatible for VR.
+
+## Code Example
+
+```js
+const gui = new GUI( { width: 300 } ); // create lil-gui instance
+const mesh = new HTMLMesh( gui.domElement );
+scene.add( mesh );
+```
+
+## Import
+
+HTMLMesh is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { HTMLMesh } from 'three/addons/interactive/HTMLMesh.js';
+```
+
+## Constructor
+
+### new HTMLMesh( dom : HTMLElement )
+
+Constructs a new HTML mesh.
+
+**dom**
+
+The DOM element to display as a plane mesh.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance and removes all event listeners. Call this method whenever this instance is no longer used in your app.
+
+## Source
+
+[examples/jsm/interactive/HTMLMesh.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/interactive/HTMLMesh.js)
\ No newline at end of file
diff --git a/docs/pages/HalftonePass.html.md b/docs/pages/HalftonePass.html.md
new file mode 100644
index 00000000000000..b38b4132020044
--- /dev/null
+++ b/docs/pages/HalftonePass.html.md
@@ -0,0 +1,104 @@
+*Inheritance: Pass →*
+
+# HalftonePass
+
+Pass for creating a RGB halftone effect.
+
+## Code Example
+
+```js
+const params = {
+ shape: 1,
+ radius: 4,
+ rotateR: Math.PI / 12,
+ rotateB: Math.PI / 12 * 2,
+ rotateG: Math.PI / 12 * 3,
+ scatter: 0,
+ blending: 1,
+ blendingMode: 1,
+ greyscale: false,
+ disable: false
+};
+const halftonePass = new HalftonePass( params );
+composer.addPass( halftonePass );
+```
+
+## Import
+
+HalftonePass is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { HalftonePass } from 'three/addons/postprocessing/HalftonePass.js';
+```
+
+## Constructor
+
+### new HalftonePass( params : Object )
+
+Constructs a new halftone pass.
+
+**params**
+
+The halftone shader parameter.
+
+## Properties
+
+### .material : ShaderMaterial
+
+The pass material.
+
+### .uniforms : Object
+
+The pass uniforms.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever the pass is no longer used in your app.
+
+**Overrides:** [Pass#dispose](Pass.html#dispose)
+
+### .render( renderer : WebGLRenderer, writeBuffer : WebGLRenderTarget, readBuffer : WebGLRenderTarget, deltaTime : number, maskActive : boolean )
+
+Performs the halftone pass.
+
+**renderer**
+
+The renderer.
+
+**writeBuffer**
+
+The write buffer. This buffer is intended as the rendering destination for the pass.
+
+**readBuffer**
+
+The read buffer. The pass can access the result from the previous pass from this buffer.
+
+**deltaTime**
+
+The delta time in seconds.
+
+**maskActive**
+
+Whether masking is active or not.
+
+**Overrides:** [Pass#render](Pass.html#render)
+
+### .setSize( width : number, height : number )
+
+Sets the size of the pass.
+
+**width**
+
+The width to set.
+
+**height**
+
+The height to set.
+
+**Overrides:** [Pass#setSize](Pass.html#setSize)
+
+## Source
+
+[examples/jsm/postprocessing/HalftonePass.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/HalftonePass.js)
\ No newline at end of file
diff --git a/docs/pages/HeartCurve.html.md b/docs/pages/HeartCurve.html.md
new file mode 100644
index 00000000000000..daf367cf0f97c0
--- /dev/null
+++ b/docs/pages/HeartCurve.html.md
@@ -0,0 +1,55 @@
+*Inheritance: Curve →*
+
+# HeartCurve
+
+A heart curve.
+
+## Import
+
+HeartCurve is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { HeartCurve } from 'three/addons/curves/CurveExtras.js';
+```
+
+## Constructor
+
+### new HeartCurve( scale : number )
+
+Constructs a new heart curve.
+
+**scale**
+
+The curve's scale.
+
+Default is `5`.
+
+## Properties
+
+### .scale : number
+
+The curve's scale.
+
+Default is `5`.
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector3 ) : Vector3
+
+This method returns a vector in 3D space for the given interpolation factor.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve.
+
+## Source
+
+[examples/jsm/curves/CurveExtras.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/curves/CurveExtras.js)
\ No newline at end of file
diff --git a/docs/pages/HelixCurve.html.md b/docs/pages/HelixCurve.html.md
new file mode 100644
index 00000000000000..431088035d829d
--- /dev/null
+++ b/docs/pages/HelixCurve.html.md
@@ -0,0 +1,39 @@
+*Inheritance: Curve →*
+
+# HelixCurve
+
+A helix curve.
+
+## Import
+
+HelixCurve is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { HelixCurve } from 'three/addons/curves/CurveExtras.js';
+```
+
+## Constructor
+
+### new HelixCurve()
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector3 ) : Vector3
+
+This method returns a vector in 3D space for the given interpolation factor.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve.
+
+## Source
+
+[examples/jsm/curves/CurveExtras.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/curves/CurveExtras.js)
\ No newline at end of file
diff --git a/docs/pages/HemisphereLight.html.md b/docs/pages/HemisphereLight.html.md
new file mode 100644
index 00000000000000..a670ed1a01cbc5
--- /dev/null
+++ b/docs/pages/HemisphereLight.html.md
@@ -0,0 +1,54 @@
+*Inheritance: EventDispatcher → Object3D → Light →*
+
+# HemisphereLight
+
+A light source positioned directly above the scene, with color fading from the sky color to the ground color.
+
+This light cannot be used to cast shadows.
+
+## Code Example
+
+```js
+const light = new THREE.HemisphereLight( 0xffffbb, 0x080820, 1 );
+scene.add( light );
+```
+
+## Constructor
+
+### new HemisphereLight( skyColor : number | Color | string, groundColor : number | Color | string, intensity : number )
+
+Constructs a new hemisphere light.
+
+**skyColor**
+
+The light's sky color.
+
+Default is `0xffffff`.
+
+**groundColor**
+
+The light's ground color.
+
+Default is `0xffffff`.
+
+**intensity**
+
+The light's strength/intensity.
+
+Default is `1`.
+
+## Properties
+
+### .groundColor : Color
+
+The light's ground color.
+
+### .isHemisphereLight : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/lights/HemisphereLight.js](https://github.com/mrdoob/three.js/blob/master/src/lights/HemisphereLight.js)
\ No newline at end of file
diff --git a/docs/pages/HemisphereLightHelper.html.md b/docs/pages/HemisphereLightHelper.html.md
new file mode 100644
index 00000000000000..25f455bc7d86b1
--- /dev/null
+++ b/docs/pages/HemisphereLightHelper.html.md
@@ -0,0 +1,57 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# HemisphereLightHelper
+
+Creates a visual aid consisting of a spherical mesh for a given [HemisphereLight](HemisphereLight.html).
+
+## Code Example
+
+```js
+const light = new THREE.HemisphereLight( 0xffffbb, 0x080820, 1 );
+const helper = new THREE.HemisphereLightHelper( light, 5 );
+scene.add( helper );
+```
+
+## Constructor
+
+### new HemisphereLightHelper( light : HemisphereLight, size : number, color : number | Color | string )
+
+Constructs a new hemisphere light helper.
+
+**light**
+
+The light to be visualized.
+
+**size**
+
+The size of the mesh used to visualize the light.
+
+Default is `1`.
+
+**color**
+
+The helper's color. If not set, the helper will take the color of the light.
+
+## Properties
+
+### .color : number | Color | string
+
+The color parameter passed in the constructor. If not set, the helper will take the color of the light.
+
+### .light : HemisphereLight
+
+The light being visualized.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+### .update()
+
+Updates the helper to match the position and direction of the light being visualized.
+
+## Source
+
+[src/helpers/HemisphereLightHelper.js](https://github.com/mrdoob/three.js/blob/master/src/helpers/HemisphereLightHelper.js)
\ No newline at end of file
diff --git a/docs/pages/HemisphereLightNode.html.md b/docs/pages/HemisphereLightNode.html.md
new file mode 100644
index 00000000000000..61e523f81070c5
--- /dev/null
+++ b/docs/pages/HemisphereLightNode.html.md
@@ -0,0 +1,47 @@
+*Inheritance: EventDispatcher → Node → LightingNode → AnalyticLightNode →*
+
+# HemisphereLightNode
+
+Module for representing hemisphere lights as nodes.
+
+## Constructor
+
+### new HemisphereLightNode( light : HemisphereLight )
+
+Constructs a new hemisphere light node.
+
+**light**
+
+The hemisphere light source.
+
+Default is `null`.
+
+## Properties
+
+### .groundColorNode : UniformNode.
+
+Uniform node representing the light's ground color.
+
+### .lightDirectionNode : Node.
+
+A node representing the light's direction.
+
+### .lightPositionNode : UniformNode.
+
+Uniform node representing the light's position.
+
+## Methods
+
+### .update( frame : NodeFrame )
+
+Overwritten to updated hemisphere light specific uniforms.
+
+**frame**
+
+A reference to the current node frame.
+
+**Overrides:** [AnalyticLightNode#update](AnalyticLightNode.html#update)
+
+## Source
+
+[src/nodes/lighting/HemisphereLightNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/lighting/HemisphereLightNode.js)
\ No newline at end of file
diff --git a/docs/pages/IESLoader.html.md b/docs/pages/IESLoader.html.md
new file mode 100644
index 00000000000000..0189fa83dea2d1
--- /dev/null
+++ b/docs/pages/IESLoader.html.md
@@ -0,0 +1,82 @@
+*Inheritance: Loader →*
+
+# IESLoader
+
+A loader for the IES format.
+
+The loaded texture should be assigned to [IESSpotLight#map](IESSpotLight.html#map).
+
+## Code Example
+
+```js
+const loader = new IESLoader();
+const texture = await loader.loadAsync( 'ies/007cfb11e343e2f42e3b476be4ab684e.ies' );
+const spotLight = new THREE.IESSpotLight( 0xff0000, 500 );
+spotLight.iesMap = texture;
+```
+
+## Import
+
+IESLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { IESLoader } from 'three/addons/loaders/IESLoader.js';
+```
+
+## Constructor
+
+### new IESLoader( manager : LoadingManager )
+
+Constructs a new IES loader.
+
+**manager**
+
+The loading manager.
+
+## Properties
+
+### .type : HalfFloatType | FloatType
+
+The texture type.
+
+Default is `HalfFloatType`.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded IES texture to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( text : string ) : DataTexture
+
+Parses the given IES data.
+
+**text**
+
+The raw IES data.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** THE IES data as a texture.
+
+## Source
+
+[examples/jsm/loaders/IESLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/IESLoader.js)
\ No newline at end of file
diff --git a/docs/pages/IESSpotLight.html.md b/docs/pages/IESSpotLight.html.md
new file mode 100644
index 00000000000000..80e383bd9e4c93
--- /dev/null
+++ b/docs/pages/IESSpotLight.html.md
@@ -0,0 +1,59 @@
+*Inheritance: EventDispatcher → Object3D → Light → SpotLight →*
+
+# IESSpotLight
+
+A IES version of [SpotLight](SpotLight.html). Can only be used with [WebGPURenderer](WebGPURenderer.html).
+
+## Constructor
+
+### new IESSpotLight( color : number | Color | string, intensity : number, distance : number, angle : number, penumbra : number, decay : number )
+
+Constructs a new IES spot light.
+
+**color**
+
+The light's color.
+
+Default is `0xffffff`.
+
+**intensity**
+
+The light's strength/intensity measured in candela (cd).
+
+Default is `1`.
+
+**distance**
+
+Maximum range of the light. `0` means no limit.
+
+Default is `0`.
+
+**angle**
+
+Maximum angle of light dispersion from its direction whose upper bound is `Math.PI/2`.
+
+Default is `Math.PI/3`.
+
+**penumbra**
+
+Percent of the spotlight cone that is attenuated due to penumbra. Value range is `[0,1]`.
+
+Default is `0`.
+
+**decay**
+
+The amount the light dims along the distance of the light.
+
+Default is `2`.
+
+## Properties
+
+### .iesMap : Texture
+
+TODO
+
+Default is `null`.
+
+## Source
+
+[src/lights/webgpu/IESSpotLight.js](https://github.com/mrdoob/three.js/blob/master/src/lights/webgpu/IESSpotLight.js)
\ No newline at end of file
diff --git a/docs/pages/IESSpotLightNode.html.md b/docs/pages/IESSpotLightNode.html.md
new file mode 100644
index 00000000000000..f22172618c8ea1
--- /dev/null
+++ b/docs/pages/IESSpotLightNode.html.md
@@ -0,0 +1,31 @@
+*Inheritance: EventDispatcher → Node → LightingNode → AnalyticLightNode → SpotLightNode →*
+
+# IESSpotLightNode
+
+An IES version of the default spot light node.
+
+## Constructor
+
+### new IESSpotLightNode()
+
+## Methods
+
+### .getSpotAttenuation( builder : NodeBuilder, angleCosine : Node. ) : Node.
+
+Overwrites the default implementation to compute an IES conform spot attenuation.
+
+**builder**
+
+The node builder.
+
+**angleCosine**
+
+The angle to compute the spot attenuation for.
+
+**Overrides:** [SpotLightNode#getSpotAttenuation](SpotLightNode.html#getSpotAttenuation)
+
+**Returns:** The spot attenuation.
+
+## Source
+
+[src/nodes/lighting/IESSpotLightNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/lighting/IESSpotLightNode.js)
\ No newline at end of file
diff --git a/docs/pages/IcosahedronGeometry.html.md b/docs/pages/IcosahedronGeometry.html.md
new file mode 100644
index 00000000000000..d02c40963724ed
--- /dev/null
+++ b/docs/pages/IcosahedronGeometry.html.md
@@ -0,0 +1,56 @@
+*Inheritance: EventDispatcher → BufferGeometry → PolyhedronGeometry →*
+
+# IcosahedronGeometry
+
+A geometry class for representing an icosahedron.
+
+## Code Example
+
+```js
+const geometry = new THREE.IcosahedronGeometry();
+const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
+const icosahedron = new THREE.Mesh( geometry, material );
+scene.add( icosahedron );
+```
+
+## Constructor
+
+### new IcosahedronGeometry( radius : number, detail : number )
+
+Constructs a new icosahedron geometry.
+
+**radius**
+
+Radius of the icosahedron.
+
+Default is `1`.
+
+**detail**
+
+Setting this to a value greater than `0` adds vertices making it no longer a icosahedron.
+
+Default is `0`.
+
+## Properties
+
+### .parameters : Object
+
+Holds the constructor parameters that have been used to generate the geometry. Any modification after instantiation does not change the geometry.
+
+**Overrides:** [PolyhedronGeometry#parameters](PolyhedronGeometry.html#parameters)
+
+## Static Methods
+
+### .fromJSON( data : Object ) : IcosahedronGeometry
+
+Factory method for creating an instance of this class from the given JSON object.
+
+**data**
+
+A JSON object representing the serialized geometry.
+
+**Returns:** A new instance.
+
+## Source
+
+[src/geometries/IcosahedronGeometry.js](https://github.com/mrdoob/three.js/blob/master/src/geometries/IcosahedronGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/ImageBitmapLoader.html.md b/docs/pages/ImageBitmapLoader.html.md
new file mode 100644
index 00000000000000..73cebb788b597a
--- /dev/null
+++ b/docs/pages/ImageBitmapLoader.html.md
@@ -0,0 +1,97 @@
+*Inheritance: Loader →*
+
+# ImageBitmapLoader
+
+A loader for loading images as an [ImageBitmap](https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap). An `ImageBitmap` provides an asynchronous and resource efficient pathway to prepare textures for rendering.
+
+Note that [Texture#flipY](Texture.html#flipY) and [Texture#premultiplyAlpha](Texture.html#premultiplyAlpha) are ignored with image bitmaps. These options need to be configured via [ImageBitmapLoader#setOptions](ImageBitmapLoader.html#setOptions) prior to loading, unlike regular images which can be configured on the Texture to set these options on GPU upload instead.
+
+To match the default behaviour of [Texture](Texture.html), the following options are needed:
+
+Also note that unlike [FileLoader](FileLoader.html), this loader will only avoid multiple concurrent requests to the same URL if [Cache](Cache.html) is enabled.
+
+```js
+const loader = new THREE.ImageBitmapLoader();
+loader.setOptions( { imageOrientation: 'flipY' } ); // set options if needed
+const imageBitmap = await loader.loadAsync( 'image.png' );
+const texture = new THREE.Texture( imageBitmap );
+texture.needsUpdate = true;
+```
+
+## Code Example
+
+```js
+{ imageOrientation: 'flipY', premultiplyAlpha: 'none' }
+```
+
+## Constructor
+
+### new ImageBitmapLoader( manager : LoadingManager )
+
+Constructs a new image bitmap loader.
+
+**manager**
+
+The loading manager.
+
+## Properties
+
+### .isImageBitmapLoader : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .options : Object
+
+Represents the loader options.
+
+Default is `{premultiplyAlpha:'none'}`.
+
+## Methods
+
+### .abort() : ImageBitmapLoader
+
+Aborts ongoing fetch requests.
+
+**Overrides:** [Loader#abort](Loader.html#abort)
+
+**Returns:** A reference to this instance.
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback ) : ImageBitmap | undefined
+
+Starts loading from the given URL and pass the loaded image bitmap to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Unsupported in this loader.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+**Returns:** The image bitmap.
+
+### .setOptions( options : Object ) : ImageBitmapLoader
+
+Sets the given loader options. The structure of the object must match the `options` parameter of [createImageBitmap](https://developer.mozilla.org/en-US/docs/Web/API/Window/createImageBitmap).
+
+**options**
+
+The loader options to set.
+
+**Returns:** A reference to this image bitmap loader.
+
+## Source
+
+[src/loaders/ImageBitmapLoader.js](https://github.com/mrdoob/three.js/blob/master/src/loaders/ImageBitmapLoader.js)
\ No newline at end of file
diff --git a/docs/pages/ImageLoader.html.md b/docs/pages/ImageLoader.html.md
new file mode 100644
index 00000000000000..272a6cb395b28b
--- /dev/null
+++ b/docs/pages/ImageLoader.html.md
@@ -0,0 +1,54 @@
+*Inheritance: Loader →*
+
+# ImageLoader
+
+A loader for loading images. The class loads images with the HTML `Image` API.
+
+Please note that `ImageLoader` has dropped support for progress events in `r84`. For an `ImageLoader` that supports progress events, see [this thread](https://github.com/mrdoob/three.js/issues/10439#issuecomment-275785639).
+
+## Code Example
+
+```js
+const loader = new THREE.ImageLoader();
+const image = await loader.loadAsync( 'image.png' );
+```
+
+## Constructor
+
+### new ImageLoader( manager : LoadingManager )
+
+Constructs a new image loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback ) : Image
+
+Starts loading from the given URL and passes the loaded image to the `onLoad()` callback. The method also returns a new `Image` object which can directly be used for texture creation. If you do it this way, the texture may pop up in your scene once the respective loading process is finished.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Unsupported in this loader.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+**Returns:** The image.
+
+## Source
+
+[src/loaders/ImageLoader.js](https://github.com/mrdoob/three.js/blob/master/src/loaders/ImageLoader.js)
\ No newline at end of file
diff --git a/docs/pages/ImageUtils.html.md b/docs/pages/ImageUtils.html.md
new file mode 100644
index 00000000000000..a17638f3b42ae4
--- /dev/null
+++ b/docs/pages/ImageUtils.html.md
@@ -0,0 +1,35 @@
+# ImageUtils
+
+A class containing utility functions for images.
+
+## Static Methods
+
+### .getDataURL( image : HTMLImageElement | HTMLCanvasElement, type : string ) : string
+
+Returns a data URI containing a representation of the given image.
+
+**image**
+
+The image object.
+
+**type**
+
+Indicates the image format.
+
+Default is `'image/png'`.
+
+**Returns:** The data URI.
+
+### .sRGBToLinear( image : HTMLImageElement | HTMLCanvasElement | ImageBitmap | Object ) : HTMLCanvasElement | Object
+
+Converts the given sRGB image data to linear color space.
+
+**image**
+
+The image object.
+
+**Returns:** The converted image.
+
+## Source
+
+[src/extras/ImageUtils.js](https://github.com/mrdoob/three.js/blob/master/src/extras/ImageUtils.js)
\ No newline at end of file
diff --git a/docs/pages/ImprovedNoise.html.md b/docs/pages/ImprovedNoise.html.md
new file mode 100644
index 00000000000000..5ee85ba3152a01
--- /dev/null
+++ b/docs/pages/ImprovedNoise.html.md
@@ -0,0 +1,41 @@
+# ImprovedNoise
+
+A utility class providing a 3D noise function.
+
+The code is based on [IMPROVED NOISE](https://cs.nyu.edu/~perlin/noise/) by Ken Perlin, 2002.
+
+## Import
+
+ImprovedNoise is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { ImprovedNoise } from 'three/addons/math/ImprovedNoise.js';
+```
+
+## Constructor
+
+### new ImprovedNoise()
+
+## Methods
+
+### .noise( x : number, y : number, z : number ) : number
+
+Returns a noise value for the given parameters.
+
+**x**
+
+The x coordinate.
+
+**y**
+
+The y coordinate.
+
+**z**
+
+The z coordinate.
+
+**Returns:** The noise value.
+
+## Source
+
+[examples/jsm/math/ImprovedNoise.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/math/ImprovedNoise.js)
\ No newline at end of file
diff --git a/docs/pages/IndexNode.html.md b/docs/pages/IndexNode.html.md
new file mode 100644
index 00000000000000..d1799cdadc1249
--- /dev/null
+++ b/docs/pages/IndexNode.html.md
@@ -0,0 +1,38 @@
+*Inheritance: EventDispatcher → Node →*
+
+# IndexNode
+
+This class represents shader indices of different types. The following predefined node objects cover frequent use cases:
+
+* `vertexIndex`: The index of a vertex within a mesh.
+* `instanceIndex`: The index of either a mesh instance or an invocation of a compute shader.
+* `drawIndex`: The index of a draw call.
+* `invocationLocalIndex`: The index of a compute invocation within the scope of a workgroup load.
+* `invocationSubgroupIndex`: The index of a compute invocation within the scope of a subgroup.
+* `subgroupIndex`: The index of a compute invocation's subgroup within its workgroup.
+
+## Constructor
+
+### new IndexNode( scope : 'vertex' | 'instance' | 'subgroup' | 'invocationLocal' | 'invocationGlobal' | 'invocationSubgroup' | 'draw' )
+
+Constructs a new index node.
+
+**scope**
+
+The scope of the index node.
+
+## Properties
+
+### .isIndexNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .scope : string
+
+The scope of the index node.
+
+## Source
+
+[src/nodes/core/IndexNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/core/IndexNode.js)
\ No newline at end of file
diff --git a/docs/pages/IndirectStorageBufferAttribute.html.md b/docs/pages/IndirectStorageBufferAttribute.html.md
new file mode 100644
index 00000000000000..a8c1cf85e6c800
--- /dev/null
+++ b/docs/pages/IndirectStorageBufferAttribute.html.md
@@ -0,0 +1,33 @@
+*Inheritance: BufferAttribute → StorageBufferAttribute →*
+
+# IndirectStorageBufferAttribute
+
+This special type of buffer attribute is intended for compute shaders. It can be used to encode draw parameters for indirect draw calls.
+
+Note: This type of buffer attribute can only be used with `WebGPURenderer` and a WebGPU backend.
+
+## Constructor
+
+### new IndirectStorageBufferAttribute( count : number | Uint32Array, itemSize : number )
+
+Constructs a new storage buffer attribute.
+
+**count**
+
+The item count. It is also valid to pass a `Uint32Array` as an argument. The subsequent parameter is then obsolete.
+
+**itemSize**
+
+The item size.
+
+## Properties
+
+### .isIndirectStorageBufferAttribute : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/renderers/common/IndirectStorageBufferAttribute.js](https://github.com/mrdoob/three.js/blob/master/src/renderers/common/IndirectStorageBufferAttribute.js)
\ No newline at end of file
diff --git a/docs/pages/Info.html.md b/docs/pages/Info.html.md
new file mode 100644
index 00000000000000..3a538a6a29a7c4
--- /dev/null
+++ b/docs/pages/Info.html.md
@@ -0,0 +1,131 @@
+# Info
+
+This renderer module provides a series of statistical information about the GPU memory and the rendering process. Useful for debugging and monitoring.
+
+## Constructor
+
+### new Info()
+
+Constructs a new info component.
+
+## Properties
+
+### .autoReset : boolean
+
+Whether frame related metrics should automatically be resetted or not. This property should be set to `false` by apps which manage their own animation loop. They must then call `renderer.info.reset()` once per frame manually.
+
+Default is `true`.
+
+### .calls : number (readonly)
+
+The number of render calls since the app has been started.
+
+Default is `0`.
+
+### .compute : Object (readonly)
+
+Compute related metrics.
+
+**calls**
+number
+
+The number of compute calls since the app has been started.
+
+**frameCalls**
+number
+
+The number of compute calls of the current frame.
+
+**timestamp**
+number
+
+The timestamp of the frame when using `renderer.computeAsync()`.
+
+### .frame : number (readonly)
+
+The current frame ID. This ID is managed by `NodeFrame`.
+
+Default is `0`.
+
+### .memory : Object (readonly)
+
+Memory related metrics.
+
+**geometries**
+number
+
+The number of active geometries.
+
+**frameCalls**
+number
+
+The number of active textures.
+
+### .render : Object (readonly)
+
+Render related metrics.
+
+**calls**
+number
+
+The number of render calls since the app has been started.
+
+**frameCalls**
+number
+
+The number of render calls of the current frame.
+
+**drawCalls**
+number
+
+The number of draw calls of the current frame.
+
+**triangles**
+number
+
+The number of rendered triangle primitives of the current frame.
+
+**points**
+number
+
+The number of rendered point primitives of the current frame.
+
+**lines**
+number
+
+The number of rendered line primitives of the current frame.
+
+**timestamp**
+number
+
+The timestamp of the frame.
+
+## Methods
+
+### .dispose()
+
+Performs a complete reset of the object.
+
+### .reset()
+
+Resets frame related metrics.
+
+### .update( object : Object3D, count : number, instanceCount : number )
+
+This method should be executed per draw call and updates the corresponding metrics.
+
+**object**
+
+The 3D object that is going to be rendered.
+
+**count**
+
+The vertex or index count.
+
+**instanceCount**
+
+The instance count.
+
+## Source
+
+[src/renderers/common/Info.js](https://github.com/mrdoob/three.js/blob/master/src/renderers/common/Info.js)
\ No newline at end of file
diff --git a/docs/pages/InputNode.html.md b/docs/pages/InputNode.html.md
new file mode 100644
index 00000000000000..c71bea1226c8ea
--- /dev/null
+++ b/docs/pages/InputNode.html.md
@@ -0,0 +1,67 @@
+*Inheritance: EventDispatcher → Node →*
+
+# InputNode
+
+Base class for representing data input nodes.
+
+## Constructor
+
+### new InputNode( value : any, nodeType : string )
+
+Constructs a new input node.
+
+**value**
+
+The value of this node. This can be any JS primitive, functions, array buffers or even three.js objects (vector, matrices, colors).
+
+**nodeType**
+
+The node type. If no explicit type is defined, the node tries to derive the type from its value.
+
+Default is `null`.
+
+## Properties
+
+### .isInputNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .precision : 'low' | 'medium' | 'high'
+
+The precision of the value in the shader.
+
+Default is `null`.
+
+### .value : any
+
+The value of this node. This can be any JS primitive, functions, array buffers or even three.js objects (vector, matrices, colors).
+
+## Methods
+
+### .getInputType( builder : NodeBuilder ) : string
+
+Returns the input type of the node which is by default the node type. Derived modules might overwrite this method and use a fixed type or compute one analytically.
+
+A typical example for different input and node types are textures. The input type of a normal RGBA texture is `texture` whereas its node type is `vec4`.
+
+**builder**
+
+The current node builder.
+
+**Returns:** The input type.
+
+### .setPrecision( precision : 'low' | 'medium' | 'high' ) : InputNode
+
+Sets the precision to the given value. The method can be overwritten in derived classes if the final precision must be computed analytically.
+
+**precision**
+
+The precision of the input value in the shader.
+
+**Returns:** A reference to this node.
+
+## Source
+
+[src/nodes/core/InputNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/core/InputNode.js)
\ No newline at end of file
diff --git a/docs/pages/InspectorBase.html.md b/docs/pages/InspectorBase.html.md
new file mode 100644
index 00000000000000..0e66f24825b642
--- /dev/null
+++ b/docs/pages/InspectorBase.html.md
@@ -0,0 +1,281 @@
+# InspectorBase
+
+### new InspectorBase()
+
+InspectorBase is the base class for all inspectors.
+
+## Properties
+
+### .currentFrame : Object
+
+The current frame being processed.
+
+### .nodeFrame
+
+Returns the node frame for the current renderer.
+
+## Methods
+
+### .begin()
+
+Called when a frame begins.
+
+### .beginCompute( uid : string, computeNode : ComputeNode )
+
+Called when a compute operation begins.
+
+**uid**
+
+A unique identifier for the render context.
+
+**computeNode**
+
+The compute node being executed.
+
+### .beginRender( uid : string, scene : Scene, camera : Camera, renderTarget : WebGLRenderTarget )
+
+Called when a render operation begins.
+
+**uid**
+
+A unique identifier for the render context.
+
+**scene**
+
+The scene being rendered.
+
+**camera**
+
+The camera being used for rendering.
+
+**renderTarget**
+
+The render target, if any.
+
+### .computeAsync( computeNode : ComputeNode, dispatchSizeOrCount : number | Array. )
+
+When a compute operation is performed.
+
+**computeNode**
+
+The compute node being executed.
+
+**dispatchSizeOrCount**
+
+The dispatch size or count.
+
+### .copyFramebufferToTexture( framebufferTexture : Texture )
+
+Called when a framebuffer copy operation is performed.
+
+**framebufferTexture**
+
+The texture associated with the framebuffer.
+
+### .copyTextureToTexture( srcTexture : Texture, dstTexture : Texture )
+
+Called when a texture copy operation is performed.
+
+**srcTexture**
+
+The source texture.
+
+**dstTexture**
+
+The destination texture.
+
+### .finish()
+
+Called when a frame ends.
+
+### .finishCompute( uid : string, computeNode : ComputeNode )
+
+Called when a compute operation ends.
+
+**uid**
+
+A unique identifier for the render context.
+
+**computeNode**
+
+The compute node being executed.
+
+### .finishRender( uid : string )
+
+Called when an animation loop ends.
+
+**uid**
+
+A unique identifier for the render context.
+
+### .getRenderer() : WebGLRenderer
+
+Returns the renderer associated with this inspector.
+
+**Returns:** The associated renderer.
+
+### .init()
+
+Initializes the inspector.
+
+### .inspect( node : Node )
+
+Inspects a node.
+
+**node**
+
+The node to inspect.
+
+### .setRenderer( renderer : WebGLRenderer ) : InspectorBase
+
+Sets the renderer for this inspector.
+
+**renderer**
+
+The renderer to associate with this inspector.
+
+**Returns:** This inspector instance.
+
+## Source
+
+[src/renderers/common/InspectorBase.js](https://github.com/mrdoob/three.js/blob/master/src/renderers/common/InspectorBase.js)
+
+### new InspectorBase()
+
+Creates a new InspectorBase.
+
+## Properties
+
+### .currentFrame : Object
+
+The current frame being processed.
+
+### .nodeFrame
+
+Returns the node frame for the current renderer.
+
+## Methods
+
+### .begin()
+
+Called when a frame begins.
+
+### .beginCompute( uid : string, computeNode : ComputeNode )
+
+Called when a compute operation begins.
+
+**uid**
+
+A unique identifier for the render context.
+
+**computeNode**
+
+The compute node being executed.
+
+### .beginRender( uid : string, scene : Scene, camera : Camera, renderTarget : WebGLRenderTarget )
+
+Called when a render operation begins.
+
+**uid**
+
+A unique identifier for the render context.
+
+**scene**
+
+The scene being rendered.
+
+**camera**
+
+The camera being used for rendering.
+
+**renderTarget**
+
+The render target, if any.
+
+### .computeAsync( computeNode : ComputeNode, dispatchSizeOrCount : number | Array. )
+
+When a compute operation is performed.
+
+**computeNode**
+
+The compute node being executed.
+
+**dispatchSizeOrCount**
+
+The dispatch size or count.
+
+### .copyFramebufferToTexture( framebufferTexture : Texture )
+
+Called when a framebuffer copy operation is performed.
+
+**framebufferTexture**
+
+The texture associated with the framebuffer.
+
+### .copyTextureToTexture( srcTexture : Texture, dstTexture : Texture )
+
+Called when a texture copy operation is performed.
+
+**srcTexture**
+
+The source texture.
+
+**dstTexture**
+
+The destination texture.
+
+### .finish()
+
+Called when a frame ends.
+
+### .finishCompute( uid : string, computeNode : ComputeNode )
+
+Called when a compute operation ends.
+
+**uid**
+
+A unique identifier for the render context.
+
+**computeNode**
+
+The compute node being executed.
+
+### .finishRender( uid : string )
+
+Called when an animation loop ends.
+
+**uid**
+
+A unique identifier for the render context.
+
+### .getRenderer() : WebGLRenderer
+
+Returns the renderer associated with this inspector.
+
+**Returns:** The associated renderer.
+
+### .init()
+
+Initializes the inspector.
+
+### .inspect( node : Node )
+
+Inspects a node.
+
+**node**
+
+The node to inspect.
+
+### .setRenderer( renderer : WebGLRenderer ) : InspectorBase
+
+Sets the renderer for this inspector.
+
+**renderer**
+
+The renderer to associate with this inspector.
+
+**Returns:** This inspector instance.
+
+## Source
+
+[src/renderers/common/InspectorBase.js](https://github.com/mrdoob/three.js/blob/master/src/renderers/common/InspectorBase.js)
\ No newline at end of file
diff --git a/docs/pages/InspectorNode.html.md b/docs/pages/InspectorNode.html.md
new file mode 100644
index 00000000000000..d233147b42c6d1
--- /dev/null
+++ b/docs/pages/InspectorNode.html.md
@@ -0,0 +1,75 @@
+*Inheritance: EventDispatcher → Node →*
+
+# InspectorNode
+
+InspectorNode is a wrapper node that allows inspection of node values during rendering. It can be used to debug or analyze node outputs in the rendering pipeline.
+
+## Constructor
+
+### new InspectorNode( node : Node, name : string, callback : function | null )
+
+Creates an InspectorNode.
+
+**node**
+
+The node to inspect.
+
+**name**
+
+Optional name for the inspector node.
+
+Default is `''`.
+
+**callback**
+
+Optional callback to modify the node during setup.
+
+Default is `null`.
+
+## Properties
+
+### .type
+
+Returns the type of the node.
+
+## Methods
+
+### .getName() : string
+
+Returns the name of the inspector node.
+
+### .getNodeType( builder : NodeBuilder ) : string
+
+Returns the type of the wrapped node.
+
+**builder**
+
+The node builder.
+
+**Overrides:** [Node#getNodeType](Node.html#getNodeType)
+
+### .setup( builder : NodeBuilder ) : Node
+
+Sets up the inspector node.
+
+**builder**
+
+The node builder.
+
+**Overrides:** [Node#setup](Node.html#setup)
+
+**Returns:** The setup node.
+
+### .update( frame : NodeFrame )
+
+Updates the inspector node, allowing inspection of the wrapped node.
+
+**frame**
+
+A reference to the current node frame.
+
+**Overrides:** [Node#update](Node.html#update)
+
+## Source
+
+[src/nodes/core/InspectorNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/core/InspectorNode.js)
\ No newline at end of file
diff --git a/docs/pages/InstanceNode.html.md b/docs/pages/InstanceNode.html.md
new file mode 100644
index 00000000000000..6b7f7b78f6b771
--- /dev/null
+++ b/docs/pages/InstanceNode.html.md
@@ -0,0 +1,115 @@
+*Inheritance: EventDispatcher → Node →*
+
+# InstanceNode
+
+This node implements the vertex shader logic which is required when rendering 3D objects via instancing. The code makes sure vertex positions, normals and colors can be modified via instanced data.
+
+## Constructor
+
+### new InstanceNode( count : number, instanceMatrix : InstancedBufferAttribute | StorageInstancedBufferAttribute, instanceColor : InstancedBufferAttribute | StorageInstancedBufferAttribute )
+
+Constructs a new instance node.
+
+**count**
+
+The number of instances.
+
+**instanceMatrix**
+
+Instanced buffer attribute representing the instance transformations.
+
+**instanceColor**
+
+Instanced buffer attribute representing the instance colors.
+
+Default is `null`.
+
+## Properties
+
+### .buffer : InstancedInterleavedBuffer
+
+A reference to a buffer that is used by `instanceMatrixNode`.
+
+### .bufferColor : InstancedBufferAttribute
+
+A reference to a buffer that is used by `instanceColorNode`.
+
+### .count : number
+
+The number of instances.
+
+### .instanceColor : InstancedBufferAttribute
+
+Instanced buffer attribute representing the color of instances.
+
+### .instanceColorNode : Node
+
+The node that represents the instance color data.
+
+Default is `null`.
+
+### .instanceMatrix : InstancedBufferAttribute
+
+Instanced buffer attribute representing the transformation of instances.
+
+### .instanceMatrixNode : Node
+
+The node that represents the instance matrix data.
+
+### .isStorageColor : boolean
+
+Tracks whether the color data is provided via a storage buffer.
+
+### .isStorageMatrix : boolean
+
+Tracks whether the matrix data is provided via a storage buffer.
+
+### .previousInstanceMatrixNode : Node
+
+The previous instance matrices. Required for computing motion vectors.
+
+Default is `null`.
+
+### .updateType : string
+
+The update type is set to `frame` since an update of instanced buffer data must be checked per frame.
+
+Default is `'frame'`.
+
+**Overrides:** [Node#updateType](Node.html#updateType)
+
+## Methods
+
+### .getPreviousInstancedPosition( builder : NodeBuilder ) : Node.
+
+Computes the transformed/instanced vertex position of the previous frame.
+
+**builder**
+
+The current node builder.
+
+**Returns:** The instanced position from the previous frame.
+
+### .setup( builder : NodeBuilder )
+
+Setups the internal buffers and nodes and assigns the transformed vertex data to predefined node variables for accumulation. That follows the same patterns like with morph and skinning nodes.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [Node#setup](Node.html#setup)
+
+### .update( frame : NodeFrame )
+
+Checks if the internal buffers require an update.
+
+**frame**
+
+The current node frame.
+
+**Overrides:** [Node#update](Node.html#update)
+
+## Source
+
+[src/nodes/accessors/InstanceNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/accessors/InstanceNode.js)
\ No newline at end of file
diff --git a/docs/pages/InstancedBufferAttribute.html.md b/docs/pages/InstancedBufferAttribute.html.md
new file mode 100644
index 00000000000000..6fc2dcd51b9bba
--- /dev/null
+++ b/docs/pages/InstancedBufferAttribute.html.md
@@ -0,0 +1,49 @@
+*Inheritance: BufferAttribute →*
+
+# InstancedBufferAttribute
+
+An instanced version of a buffer attribute.
+
+## Constructor
+
+### new InstancedBufferAttribute( array : TypedArray, itemSize : number, normalized : boolean, meshPerAttribute : number )
+
+Constructs a new instanced buffer attribute.
+
+**array**
+
+The array holding the attribute data.
+
+**itemSize**
+
+The item size.
+
+**normalized**
+
+Whether the data are normalized or not.
+
+Default is `false`.
+
+**meshPerAttribute**
+
+How often a value of this buffer attribute should be repeated.
+
+Default is `1`.
+
+## Properties
+
+### .isInstancedBufferAttribute : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .meshPerAttribute : number
+
+Defines how often a value of this buffer attribute should be repeated. A value of one means that each value of the instanced attribute is used for a single instance. A value of two means that each value is used for two consecutive instances (and so on).
+
+Default is `1`.
+
+## Source
+
+[src/core/InstancedBufferAttribute.js](https://github.com/mrdoob/three.js/blob/master/src/core/InstancedBufferAttribute.js)
\ No newline at end of file
diff --git a/docs/pages/InstancedBufferGeometry.html.md b/docs/pages/InstancedBufferGeometry.html.md
new file mode 100644
index 00000000000000..9bef66ead10f2b
--- /dev/null
+++ b/docs/pages/InstancedBufferGeometry.html.md
@@ -0,0 +1,27 @@
+# InstancedBufferGeometry
+
+An instanced version of a geometry.
+
+## Constructor
+
+### new InstancedBufferGeometry()
+
+Constructs a new instanced buffer geometry.
+
+## Properties
+
+### .instanceCount : number
+
+The instance count.
+
+Default is `Infinity`.
+
+### .isInstancedBufferGeometry : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/core/InstancedBufferGeometry.js](https://github.com/mrdoob/three.js/blob/master/src/core/InstancedBufferGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/InstancedFlow.html.md b/docs/pages/InstancedFlow.html.md
new file mode 100644
index 00000000000000..54fcc0a8f7555c
--- /dev/null
+++ b/docs/pages/InstancedFlow.html.md
@@ -0,0 +1,79 @@
+*Inheritance: Flow →*
+
+# InstancedFlow
+
+An instanced version of [Flow](Flow.html) for making meshes bend around curves, where the instances are placed on the curve.
+
+This module can only be used with [WebGLRenderer](WebGLRenderer.html).
+
+## Import
+
+InstancedFlow is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { InstancedFlow } from 'three/addons/modifiers/CurveModifier.js';
+```
+
+## Constructor
+
+### new InstancedFlow( count : number, curveCount : number, geometry : Geometry, material : Material )
+
+Constructs a new InstancedFlow instance.
+
+**count**
+
+The number of instanced elements.
+
+**curveCount**
+
+The number of curves to preallocate for.
+
+**geometry**
+
+The geometry to use for the instanced mesh.
+
+**material**
+
+The material to use for the instanced mesh.
+
+## Classes
+
+[InstancedFlow](InstancedFlow.html)
+
+## Methods
+
+### .moveIndividualAlongCurve( index : number, offset : number )
+
+Move an individual element along the curve by a specific amount.
+
+**index**
+
+Which element to update.
+
+**offset**
+
+The offset.
+
+### .setCurve( index : number, curveNo : number )
+
+Select which curve to use for an element.
+
+**index**
+
+The index of the instanced element to update.
+
+**curveNo**
+
+The index of the curve it should use.
+
+### .writeChanges( index : number )
+
+The extra information about which curve and curve position is stored in the translation components of the matrix for the instanced objects This writes that information to the matrix and marks it as needing update.
+
+**index**
+
+The index of tge instanced element to update.
+
+## Source
+
+[examples/jsm/modifiers/CurveModifier.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/modifiers/CurveModifier.js)
\ No newline at end of file
diff --git a/docs/pages/InstancedInterleavedBuffer.html.md b/docs/pages/InstancedInterleavedBuffer.html.md
new file mode 100644
index 00000000000000..c624ce4c0ffdf4
--- /dev/null
+++ b/docs/pages/InstancedInterleavedBuffer.html.md
@@ -0,0 +1,43 @@
+*Inheritance: InterleavedBuffer →*
+
+# InstancedInterleavedBuffer
+
+An instanced version of an interleaved buffer.
+
+## Constructor
+
+### new InstancedInterleavedBuffer( array : TypedArray, stride : number, meshPerAttribute : number )
+
+Constructs a new instanced interleaved buffer.
+
+**array**
+
+A typed array with a shared buffer storing attribute data.
+
+**stride**
+
+The number of typed-array elements per vertex.
+
+**meshPerAttribute**
+
+Defines how often a value of this interleaved buffer should be repeated.
+
+Default is `1`.
+
+## Properties
+
+### .isInstancedInterleavedBuffer : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .meshPerAttribute : number
+
+Defines how often a value of this buffer attribute should be repeated, see [InstancedBufferAttribute#meshPerAttribute](InstancedBufferAttribute.html#meshPerAttribute).
+
+Default is `1`.
+
+## Source
+
+[src/core/InstancedInterleavedBuffer.js](https://github.com/mrdoob/three.js/blob/master/src/core/InstancedInterleavedBuffer.js)
\ No newline at end of file
diff --git a/docs/pages/InstancedMesh.html.md b/docs/pages/InstancedMesh.html.md
new file mode 100644
index 00000000000000..66e5934c830ec6
--- /dev/null
+++ b/docs/pages/InstancedMesh.html.md
@@ -0,0 +1,161 @@
+*Inheritance: EventDispatcher → Object3D → Mesh →*
+
+# InstancedMesh
+
+A special version of a mesh with instanced rendering support. Use this class if you have to render a large number of objects with the same geometry and material(s) but with different world transformations. The usage of 'InstancedMesh' will help you to reduce the number of draw calls and thus improve the overall rendering performance in your application.
+
+## Constructor
+
+### new InstancedMesh( geometry : BufferGeometry, material : Material | Array., count : number )
+
+Constructs a new instanced mesh.
+
+**geometry**
+
+The mesh geometry.
+
+**material**
+
+The mesh material.
+
+**count**
+
+The number of instances.
+
+## Properties
+
+### .boundingBox : Box3
+
+The bounding box of the instanced mesh. Can be computed via [InstancedMesh#computeBoundingBox](InstancedMesh.html#computeBoundingBox).
+
+Default is `null`.
+
+### .boundingSphere : Sphere
+
+The bounding sphere of the instanced mesh. Can be computed via [InstancedMesh#computeBoundingSphere](InstancedMesh.html#computeBoundingSphere).
+
+Default is `null`.
+
+### .count : number
+
+The number of instances.
+
+**Overrides:** [Mesh#count](Mesh.html#count)
+
+### .instanceColor : InstancedBufferAttribute
+
+Represents the color of all instances. You have to set its [BufferAttribute#needsUpdate](BufferAttribute.html#needsUpdate) flag to true if you modify instanced data via [InstancedMesh#setColorAt](InstancedMesh.html#setColorAt).
+
+Default is `null`.
+
+### .instanceMatrix : InstancedBufferAttribute
+
+Represents the local transformation of all instances. You have to set its [BufferAttribute#needsUpdate](BufferAttribute.html#needsUpdate) flag to true if you modify instanced data via [InstancedMesh#setMatrixAt](InstancedMesh.html#setMatrixAt).
+
+### .isInstancedMesh : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .morphTexture : DataTexture
+
+Represents the morph target weights of all instances. You have to set its [Texture#needsUpdate](Texture.html#needsUpdate) flag to true if you modify instanced data via [InstancedMesh#setMorphAt](InstancedMesh.html#setMorphAt).
+
+Default is `null`.
+
+### .previousInstanceMatrix : InstancedBufferAttribute
+
+Represents the local transformation of all instances of the previous frame. Required for computing velocity. Maintained in [InstanceNode](InstanceNode.html).
+
+Default is `null`.
+
+## Methods
+
+### .computeBoundingBox()
+
+Computes the bounding box of the instanced mesh, and updates [InstancedMesh#boundingBox](InstancedMesh.html#boundingBox). The bounding box is not automatically computed by the engine; this method must be called by your app. You may need to recompute the bounding box if an instance is transformed via [InstancedMesh#setMatrixAt](InstancedMesh.html#setMatrixAt).
+
+### .computeBoundingSphere()
+
+Computes the bounding sphere of the instanced mesh, and updates [InstancedMesh#boundingSphere](InstancedMesh.html#boundingSphere) The engine automatically computes the bounding sphere when it is needed, e.g., for ray casting or view frustum culling. You may need to recompute the bounding sphere if an instance is transformed via [InstancedMesh#setMatrixAt](InstancedMesh.html#setMatrixAt).
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+### .getColorAt( index : number, color : Color )
+
+Gets the color of the defined instance.
+
+**index**
+
+The instance index.
+
+**color**
+
+The target object that is used to store the method's result.
+
+### .getMatrixAt( index : number, matrix : Matrix4 )
+
+Gets the local transformation matrix of the defined instance.
+
+**index**
+
+The instance index.
+
+**matrix**
+
+The target object that is used to store the method's result.
+
+### .getMorphAt( index : number, object : Mesh )
+
+Gets the morph target weights of the defined instance.
+
+**index**
+
+The instance index.
+
+**object**
+
+The target object that is used to store the method's result.
+
+### .setColorAt( index : number, color : Color )
+
+Sets the given color to the defined instance. Make sure you set the `needsUpdate` flag of [InstancedMesh#instanceColor](InstancedMesh.html#instanceColor) to `true` after updating all the colors.
+
+**index**
+
+The instance index.
+
+**color**
+
+The instance color.
+
+### .setMatrixAt( index : number, matrix : Matrix4 )
+
+Sets the given local transformation matrix to the defined instance. Make sure you set the `needsUpdate` flag of [InstancedMesh#instanceMatrix](InstancedMesh.html#instanceMatrix) to `true` after updating all the colors.
+
+**index**
+
+The instance index.
+
+**matrix**
+
+The local transformation.
+
+### .setMorphAt( index : number, object : Mesh )
+
+Sets the morph target weights to the defined instance. Make sure you set the `needsUpdate` flag of [InstancedMesh#morphTexture](InstancedMesh.html#morphTexture) to `true` after updating all the influences.
+
+**index**
+
+The instance index.
+
+**object**
+
+A mesh which `morphTargetInfluences` property containing the morph target weights of a single instance.
+
+## Source
+
+[src/objects/InstancedMesh.js](https://github.com/mrdoob/three.js/blob/master/src/objects/InstancedMesh.js)
\ No newline at end of file
diff --git a/docs/pages/InstancedMeshNode.html.md b/docs/pages/InstancedMeshNode.html.md
new file mode 100644
index 00000000000000..dddddc0695d141
--- /dev/null
+++ b/docs/pages/InstancedMeshNode.html.md
@@ -0,0 +1,25 @@
+*Inheritance: EventDispatcher → Node → InstanceNode →*
+
+# InstancedMeshNode
+
+This is a special version of `InstanceNode` which requires the usage of [InstancedMesh](InstancedMesh.html). It allows an easier setup of the instance node.
+
+## Constructor
+
+### new InstancedMeshNode( instancedMesh : InstancedMesh )
+
+Constructs a new instanced mesh node.
+
+**instancedMesh**
+
+The instanced mesh.
+
+## Properties
+
+### .instancedMesh : InstancedMesh
+
+A reference to the instanced mesh.
+
+## Source
+
+[src/nodes/accessors/InstancedMeshNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/accessors/InstancedMeshNode.js)
\ No newline at end of file
diff --git a/docs/pages/Int16BufferAttribute.html.md b/docs/pages/Int16BufferAttribute.html.md
new file mode 100644
index 00000000000000..3153da6acaf9a0
--- /dev/null
+++ b/docs/pages/Int16BufferAttribute.html.md
@@ -0,0 +1,29 @@
+*Inheritance: BufferAttribute →*
+
+# Int16BufferAttribute
+
+Convenient class that can be used when creating a `Int16` buffer attribute with a plain `Array` instance.
+
+## Constructor
+
+### new Int16BufferAttribute( array : Array. | Int16Array, itemSize : number, normalized : boolean )
+
+Constructs a new buffer attribute.
+
+**array**
+
+The array holding the attribute data.
+
+**itemSize**
+
+The item size.
+
+**normalized**
+
+Whether the data are normalized or not.
+
+Default is `false`.
+
+## Source
+
+[src/core/BufferAttribute.js](https://github.com/mrdoob/three.js/blob/master/src/core/BufferAttribute.js)
\ No newline at end of file
diff --git a/docs/pages/Int32BufferAttribute.html.md b/docs/pages/Int32BufferAttribute.html.md
new file mode 100644
index 00000000000000..7750d8da64d021
--- /dev/null
+++ b/docs/pages/Int32BufferAttribute.html.md
@@ -0,0 +1,29 @@
+*Inheritance: BufferAttribute →*
+
+# Int32BufferAttribute
+
+Convenient class that can be used when creating a `Int32` buffer attribute with a plain `Array` instance.
+
+## Constructor
+
+### new Int32BufferAttribute( array : Array. | Int32Array, itemSize : number, normalized : boolean )
+
+Constructs a new buffer attribute.
+
+**array**
+
+The array holding the attribute data.
+
+**itemSize**
+
+The item size.
+
+**normalized**
+
+Whether the data are normalized or not.
+
+Default is `false`.
+
+## Source
+
+[src/core/BufferAttribute.js](https://github.com/mrdoob/three.js/blob/master/src/core/BufferAttribute.js)
\ No newline at end of file
diff --git a/docs/pages/Int8BufferAttribute.html.md b/docs/pages/Int8BufferAttribute.html.md
new file mode 100644
index 00000000000000..98abdcb79bbea2
--- /dev/null
+++ b/docs/pages/Int8BufferAttribute.html.md
@@ -0,0 +1,29 @@
+*Inheritance: BufferAttribute →*
+
+# Int8BufferAttribute
+
+Convenient class that can be used when creating a `Int8` buffer attribute with a plain `Array` instance.
+
+## Constructor
+
+### new Int8BufferAttribute( array : Array. | Int8Array, itemSize : number, normalized : boolean )
+
+Constructs a new buffer attribute.
+
+**array**
+
+The array holding the attribute data.
+
+**itemSize**
+
+The item size.
+
+**normalized**
+
+Whether the data are normalized or not.
+
+Default is `false`.
+
+## Source
+
+[src/core/BufferAttribute.js](https://github.com/mrdoob/three.js/blob/master/src/core/BufferAttribute.js)
\ No newline at end of file
diff --git a/docs/pages/InteractiveGroup.html.md b/docs/pages/InteractiveGroup.html.md
new file mode 100644
index 00000000000000..8b194bfa72ba29
--- /dev/null
+++ b/docs/pages/InteractiveGroup.html.md
@@ -0,0 +1,89 @@
+*Inheritance: EventDispatcher → Object3D → Group →*
+
+# InteractiveGroup
+
+This class can be used to group 3D objects in an interactive group. The group itself can listen to Pointer, Mouse or XR controller events to detect selections of descendant 3D objects. If a 3D object is selected, the respective event is going to dispatched to it.
+
+## Code Example
+
+```js
+const group = new InteractiveGroup();
+group.listenToPointerEvents( renderer, camera );
+group.listenToXRControllerEvents( controller1 );
+group.listenToXRControllerEvents( controller2 );
+scene.add( group );
+// now add objects that should be interactive
+group.add( mesh1, mesh2, mesh3 );
+```
+
+## Import
+
+InteractiveGroup is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { InteractiveGroup } from 'three/addons/interactive/InteractiveGroup.js';
+```
+
+## Constructor
+
+### new InteractiveGroup()
+
+## Properties
+
+### .camera : Camera
+
+The camera used for raycasting.
+
+Default is `null`.
+
+### .controllers : Array.
+
+An array of XR controllers.
+
+### .element : HTMLElement
+
+The internal raycaster.
+
+Default is `null`.
+
+### .raycaster : Raycaster
+
+The internal raycaster.
+
+## Methods
+
+### .disconnect()
+
+Disconnects this interactive group from the DOM and all XR controllers.
+
+### .disconnectXrControllerEvents()
+
+Disconnects this interactive group from all XR controllers.
+
+### .disconnectionPointerEvents()
+
+Disconnects this interactive group from all Pointer and Mouse Events.
+
+### .listenToPointerEvents( renderer : WebGPURenderer | WebGLRenderer, camera : Camera )
+
+Calling this method makes sure the interactive group listens to Pointer and Mouse events. The target is the `domElement` of the given renderer. The camera is required for the internal raycasting so 3D objects can be detected based on the events.
+
+**renderer**
+
+The renderer.
+
+**camera**
+
+The camera.
+
+### .listenToXRControllerEvents( controller : Group )
+
+Calling this method makes sure the interactive group listens to events of the given XR controller.
+
+**controller**
+
+The XR controller.
+
+## Source
+
+[examples/jsm/interactive/InteractiveGroup.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/interactive/InteractiveGroup.js)
\ No newline at end of file
diff --git a/docs/pages/InterleavedBuffer.html.md b/docs/pages/InterleavedBuffer.html.md
new file mode 100644
index 00000000000000..a27cf3d9c3301a
--- /dev/null
+++ b/docs/pages/InterleavedBuffer.html.md
@@ -0,0 +1,175 @@
+# InterleavedBuffer
+
+"Interleaved" means that multiple attributes, possibly of different types, (e.g., position, normal, uv, color) are packed into a single array buffer.
+
+An introduction into interleaved arrays can be found here: [Interleaved array basics](https://blog.tojicode.com/2011/05/interleaved-array-basics.html)
+
+## Constructor
+
+### new InterleavedBuffer( array : TypedArray, stride : number )
+
+Constructs a new interleaved buffer.
+
+**array**
+
+A typed array with a shared buffer storing attribute data.
+
+**stride**
+
+The number of typed-array elements per vertex.
+
+## Properties
+
+### .array : TypedArray
+
+A typed array with a shared buffer storing attribute data.
+
+### .count : number (readonly)
+
+The total number of elements in the array
+
+### .isInterleavedBuffer : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .needsUpdate : number
+
+Flag to indicate that this attribute has changed and should be re-sent to the GPU. Set this to `true` when you modify the value of the array.
+
+Default is `false`.
+
+### .stride : number
+
+The number of typed-array elements per vertex.
+
+### .updateRanges : Array.
+
+This can be used to only update some components of stored vectors (for example, just the component related to color). Use the `addUpdateRange()` function to add ranges to this array.
+
+### .usage : StaticDrawUsage | DynamicDrawUsage | StreamDrawUsage | StaticReadUsage | DynamicReadUsage | StreamReadUsage | StaticCopyUsage | DynamicCopyUsage | StreamCopyUsage
+
+Defines the intended usage pattern of the data store for optimization purposes.
+
+Note: After the initial use of a buffer, its usage cannot be changed. Instead, instantiate a new one and set the desired usage before the next render.
+
+Default is `StaticDrawUsage`.
+
+### .uuid : string (readonly)
+
+The UUID of the interleaved buffer.
+
+### .version : number
+
+A version number, incremented every time the `needsUpdate` is set to `true`.
+
+## Methods
+
+### .addUpdateRange( start : number, count : number )
+
+Adds a range of data in the data array to be updated on the GPU.
+
+**start**
+
+Position at which to start update.
+
+**count**
+
+The number of components to update.
+
+### .clearUpdateRanges()
+
+Clears the update ranges.
+
+### .clone( data : Object ) : InterleavedBuffer
+
+Returns a new interleaved buffer with copied values from this instance.
+
+**data**
+
+An object with shared array buffers that allows to retain shared structures.
+
+**Returns:** A clone of this instance.
+
+### .copy( source : InterleavedBuffer ) : InterleavedBuffer
+
+Copies the values of the given interleaved buffer to this instance.
+
+**source**
+
+The interleaved buffer to copy.
+
+**Returns:** A reference to this instance.
+
+### .copyAt( index1 : number, interleavedBuffer : InterleavedBuffer, index2 : number ) : InterleavedBuffer
+
+Copies a vector from the given interleaved buffer to this one. The start and destination position in the attribute buffers are represented by the given indices.
+
+**index1**
+
+The destination index into this interleaved buffer.
+
+**interleavedBuffer**
+
+The interleaved buffer to copy from.
+
+**index2**
+
+The source index into the given interleaved buffer.
+
+**Returns:** A reference to this instance.
+
+### .onUpload( callback : function ) : InterleavedBuffer
+
+Sets the given callback function that is executed after the Renderer has transferred the array data to the GPU. Can be used to perform clean-up operations after the upload when data are not needed anymore on the CPU side.
+
+**callback**
+
+The `onUpload()` callback.
+
+**Returns:** A reference to this instance.
+
+### .onUploadCallback()
+
+A callback function that is executed after the renderer has transferred the attribute array data to the GPU.
+
+### .set( value : TypedArray | Array, offset : number ) : InterleavedBuffer
+
+Sets the given array data in the interleaved buffer.
+
+**value**
+
+The array data to set.
+
+**offset**
+
+The offset in this interleaved buffer's array.
+
+Default is `0`.
+
+**Returns:** A reference to this instance.
+
+### .setUsage( value : StaticDrawUsage | DynamicDrawUsage | StreamDrawUsage | StaticReadUsage | DynamicReadUsage | StreamReadUsage | StaticCopyUsage | DynamicCopyUsage | StreamCopyUsage ) : InterleavedBuffer
+
+Sets the usage of this interleaved buffer.
+
+**value**
+
+The usage to set.
+
+**Returns:** A reference to this interleaved buffer.
+
+### .toJSON( data : Object ) : Object
+
+Serializes the interleaved buffer into JSON.
+
+**data**
+
+An optional value holding meta information about the serialization.
+
+**Returns:** A JSON object representing the serialized interleaved buffer.
+
+## Source
+
+[src/core/InterleavedBuffer.js](https://github.com/mrdoob/three.js/blob/master/src/core/InterleavedBuffer.js)
\ No newline at end of file
diff --git a/docs/pages/InterleavedBufferAttribute.html.md b/docs/pages/InterleavedBufferAttribute.html.md
new file mode 100644
index 00000000000000..44a631fc4a639a
--- /dev/null
+++ b/docs/pages/InterleavedBufferAttribute.html.md
@@ -0,0 +1,323 @@
+# InterleavedBufferAttribute
+
+An alternative version of a buffer attribute with interleaved data. Interleaved attributes share a common interleaved data storage ([InterleavedBuffer](InterleavedBuffer.html)) and refer with different offsets into the buffer.
+
+## Constructor
+
+### new InterleavedBufferAttribute( interleavedBuffer : InterleavedBuffer, itemSize : number, offset : number, normalized : boolean )
+
+Constructs a new interleaved buffer attribute.
+
+**interleavedBuffer**
+
+The buffer holding the interleaved data.
+
+**itemSize**
+
+The item size.
+
+**offset**
+
+The attribute offset into the buffer.
+
+**normalized**
+
+Whether the data are normalized or not.
+
+Default is `false`.
+
+## Properties
+
+### .array : TypedArray
+
+The array holding the interleaved buffer attribute data.
+
+### .count : number (readonly)
+
+The item count of this buffer attribute.
+
+### .data : InterleavedBuffer
+
+The buffer holding the interleaved data.
+
+### .isInterleavedBufferAttribute : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .itemSize : number
+
+The item size, see [BufferAttribute#itemSize](BufferAttribute.html#itemSize).
+
+### .name : string
+
+The name of the buffer attribute.
+
+### .needsUpdate : number
+
+Flag to indicate that this attribute has changed and should be re-sent to the GPU. Set this to `true` when you modify the value of the array.
+
+Default is `false`.
+
+### .normalized : InterleavedBuffer
+
+Whether the data are normalized or not, see [BufferAttribute#normalized](BufferAttribute.html#normalized)
+
+### .offset : number
+
+The attribute offset into the buffer.
+
+## Methods
+
+### .applyMatrix4( m : Matrix4 ) : InterleavedBufferAttribute
+
+Applies the given 4x4 matrix to the given attribute. Only works with item size `3`.
+
+**m**
+
+The matrix to apply.
+
+**Returns:** A reference to this instance.
+
+### .applyNormalMatrix( m : Matrix3 ) : InterleavedBufferAttribute
+
+Applies the given 3x3 normal matrix to the given attribute. Only works with item size `3`.
+
+**m**
+
+The normal matrix to apply.
+
+**Returns:** A reference to this instance.
+
+### .clone( data : Object ) : BufferAttribute | InterleavedBufferAttribute
+
+Returns a new buffer attribute with copied values from this instance.
+
+If no parameter is provided, cloning an interleaved buffer attribute will de-interleave buffer data.
+
+**data**
+
+An object with interleaved buffers that allows to retain the interleaved property.
+
+**Returns:** A clone of this instance.
+
+### .getComponent( index : number, component : number ) : number
+
+Returns the given component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**component**
+
+The component index.
+
+**Returns:** The returned value.
+
+### .getW( index : number ) : number
+
+Returns the w component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**Returns:** The w component.
+
+### .getX( index : number ) : number
+
+Returns the x component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**Returns:** The x component.
+
+### .getY( index : number ) : number
+
+Returns the y component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**Returns:** The y component.
+
+### .getZ( index : number ) : number
+
+Returns the z component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**Returns:** The z component.
+
+### .setComponent( index : number, component : number, value : number ) : InterleavedBufferAttribute
+
+Sets the given value to the given component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**component**
+
+The component index.
+
+**value**
+
+The value to set.
+
+**Returns:** A reference to this instance.
+
+### .setW( index : number, w : number ) : InterleavedBufferAttribute
+
+Sets the w component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**w**
+
+The value to set.
+
+**Returns:** A reference to this instance.
+
+### .setX( index : number, x : number ) : InterleavedBufferAttribute
+
+Sets the x component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**x**
+
+The value to set.
+
+**Returns:** A reference to this instance.
+
+### .setXY( index : number, x : number, y : number ) : InterleavedBufferAttribute
+
+Sets the x and y component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**x**
+
+The value for the x component to set.
+
+**y**
+
+The value for the y component to set.
+
+**Returns:** A reference to this instance.
+
+### .setXYZ( index : number, x : number, y : number, z : number ) : InterleavedBufferAttribute
+
+Sets the x, y and z component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**x**
+
+The value for the x component to set.
+
+**y**
+
+The value for the y component to set.
+
+**z**
+
+The value for the z component to set.
+
+**Returns:** A reference to this instance.
+
+### .setXYZW( index : number, x : number, y : number, z : number, w : number ) : InterleavedBufferAttribute
+
+Sets the x, y, z and w component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**x**
+
+The value for the x component to set.
+
+**y**
+
+The value for the y component to set.
+
+**z**
+
+The value for the z component to set.
+
+**w**
+
+The value for the w component to set.
+
+**Returns:** A reference to this instance.
+
+### .setY( index : number, y : number ) : InterleavedBufferAttribute
+
+Sets the y component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**y**
+
+The value to set.
+
+**Returns:** A reference to this instance.
+
+### .setZ( index : number, z : number ) : InterleavedBufferAttribute
+
+Sets the z component of the vector at the given index.
+
+**index**
+
+The index into the buffer attribute.
+
+**z**
+
+The value to set.
+
+**Returns:** A reference to this instance.
+
+### .toJSON( data : Object ) : Object
+
+Serializes the buffer attribute into JSON.
+
+If no parameter is provided, cloning an interleaved buffer attribute will de-interleave buffer data.
+
+**data**
+
+An optional value holding meta information about the serialization.
+
+**Returns:** A JSON object representing the serialized buffer attribute.
+
+### .transformDirection( m : Matrix4 ) : InterleavedBufferAttribute
+
+Applies the given 4x4 matrix to the given attribute. Only works with item size `3` and with direction vectors.
+
+**m**
+
+The matrix to apply.
+
+**Returns:** A reference to this instance.
+
+## Source
+
+[src/core/InterleavedBufferAttribute.js](https://github.com/mrdoob/three.js/blob/master/src/core/InterleavedBufferAttribute.js)
\ No newline at end of file
diff --git a/docs/pages/Interpolant.html.md b/docs/pages/Interpolant.html.md
new file mode 100644
index 00000000000000..74fbf81d17fa40
--- /dev/null
+++ b/docs/pages/Interpolant.html.md
@@ -0,0 +1,133 @@
+# Interpolant
+
+Abstract base class of interpolants over parametric samples.
+
+The parameter domain is one dimensional, typically the time or a path along a curve defined by the data.
+
+The sample values can have any dimensionality and derived classes may apply special interpretations to the data.
+
+This class provides the interval seek in a Template Method, deferring the actual interpolation to derived classes.
+
+Time complexity is O(1) for linear access crossing at most two points and O(log N) for random access, where N is the number of positions.
+
+References: [http://www.oodesign.com/template-method-pattern.html](http://www.oodesign.com/template-method-pattern.html)
+
+## Constructor
+
+### new Interpolant( parameterPositions : TypedArray, sampleValues : TypedArray, sampleSize : number, resultBuffer : TypedArray ) (abstract)
+
+Constructs a new interpolant.
+
+**parameterPositions**
+
+The parameter positions hold the interpolation factors.
+
+**sampleValues**
+
+The sample values.
+
+**sampleSize**
+
+The sample size
+
+**resultBuffer**
+
+The result buffer.
+
+## Properties
+
+### .DefaultSettings_ : Object
+
+The default settings object.
+
+### .parameterPositions : TypedArray
+
+The parameter positions.
+
+### .resultBuffer : TypedArray
+
+The result buffer.
+
+### .sampleValues : TypedArray
+
+The sample values.
+
+### .settings : Object
+
+The interpolation settings.
+
+Default is `null`.
+
+### .valueSize : TypedArray
+
+The value size.
+
+## Methods
+
+### .copySampleValue_( index : number ) : TypedArray
+
+Copies a sample value to the result buffer.
+
+**index**
+
+An index into the sample value buffer.
+
+**Returns:** The result buffer.
+
+### .evaluate( t : number ) : TypedArray
+
+Evaluate the interpolant at position `t`.
+
+**t**
+
+The interpolation factor.
+
+**Returns:** The result buffer.
+
+### .getSettings_() : Object
+
+Returns the interpolation settings.
+
+**Returns:** The interpolation settings.
+
+### .interpolate_( i1 : number, t0 : number, t : number, t1 : number ) : TypedArray (abstract)
+
+Copies a sample value to the result buffer.
+
+**i1**
+
+An index into the sample value buffer.
+
+**t0**
+
+The previous interpolation factor.
+
+**t**
+
+The current interpolation factor.
+
+**t1**
+
+The next interpolation factor.
+
+**Returns:** The result buffer.
+
+### .intervalChanged_( i1 : number, t0 : number, t : number )
+
+Optional method that is executed when the interval has changed.
+
+**i1**
+
+An index into the sample value buffer.
+
+**t0**
+
+The previous interpolation factor.
+
+**t**
+
+The current interpolation factor.
+
+## Source
+
+[src/math/Interpolant.js](https://github.com/mrdoob/three.js/blob/master/src/math/Interpolant.js)
\ No newline at end of file
diff --git a/docs/pages/IrradianceNode.html.md b/docs/pages/IrradianceNode.html.md
new file mode 100644
index 00000000000000..ef368c12c3e86e
--- /dev/null
+++ b/docs/pages/IrradianceNode.html.md
@@ -0,0 +1,25 @@
+*Inheritance: EventDispatcher → Node → LightingNode →*
+
+# IrradianceNode
+
+A generic class that can be used by nodes which contribute irradiance to the scene. E.g. a light map node can be used as input for this module. Used in [NodeMaterial](NodeMaterial.html).
+
+## Constructor
+
+### new IrradianceNode( node : Node. )
+
+Constructs a new irradiance node.
+
+**node**
+
+A node contributing irradiance.
+
+## Properties
+
+### .node : Node.
+
+A node contributing irradiance.
+
+## Source
+
+[src/nodes/lighting/IrradianceNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/lighting/IrradianceNode.js)
\ No newline at end of file
diff --git a/docs/pages/IsolateNode.html.md b/docs/pages/IsolateNode.html.md
new file mode 100644
index 00000000000000..80515acf024a2f
--- /dev/null
+++ b/docs/pages/IsolateNode.html.md
@@ -0,0 +1,43 @@
+*Inheritance: EventDispatcher → Node →*
+
+# IsolateNode
+
+This node can be used as a cache management component for another node. Caching is in general used by default in [NodeBuilder](NodeBuilder.html) but this node allows the usage of a shared parent cache during the build process.
+
+## Constructor
+
+### new IsolateNode( node : Node, parent : boolean )
+
+Constructs a new cache node.
+
+**node**
+
+The node that should be cached.
+
+**parent**
+
+Whether this node refers to a shared parent cache or not.
+
+Default is `true`.
+
+## Properties
+
+### .isIsolateNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .node : Node
+
+The node that should be cached.
+
+### .parent : boolean
+
+Whether this node refers to a shared parent cache or not.
+
+Default is `true`.
+
+## Source
+
+[src/nodes/core/IsolateNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/core/IsolateNode.js)
\ No newline at end of file
diff --git a/docs/pages/JoinNode.html.md b/docs/pages/JoinNode.html.md
new file mode 100644
index 00000000000000..078c44c54adf76
--- /dev/null
+++ b/docs/pages/JoinNode.html.md
@@ -0,0 +1,45 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# JoinNode
+
+This module is part of the TSL core and usually not used in app level code. It represents a join operation during the shader generation process. For example in can compose/join two single floats into a `vec2` type.
+
+## Constructor
+
+### new JoinNode( nodes : Array., nodeType : string )
+
+Constructs a new join node.
+
+**nodes**
+
+An array of nodes that should be joined.
+
+**nodeType**
+
+The node type.
+
+Default is `null`.
+
+## Properties
+
+### .nodes : Array.
+
+An array of nodes that should be joined.
+
+## Methods
+
+### .getNodeType( builder : NodeBuilder ) : string
+
+This method is overwritten since the node type must be inferred from the joined data length if not explicitly defined.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#getNodeType](TempNode.html#getNodeType)
+
+**Returns:** The node type.
+
+## Source
+
+[src/nodes/utils/JoinNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/utils/JoinNode.js)
\ No newline at end of file
diff --git a/docs/pages/JoltPhysics.html.md b/docs/pages/JoltPhysics.html.md
new file mode 100644
index 00000000000000..d0b0786a21ee08
--- /dev/null
+++ b/docs/pages/JoltPhysics.html.md
@@ -0,0 +1,75 @@
+# JoltPhysics
+
+Can be used to include Jolt as a Physics engine into `three.js` apps. The API can be initialized via:
+
+The component automatically imports Jolt from a CDN so make sure to use the component with an active Internet connection.
+
+## Code Example
+
+```js
+const physics = await JoltPhysics();
+```
+
+## Import
+
+JoltPhysics is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { JoltPhysics } from 'three/addons/physics/JoltPhysics.js';
+```
+
+## Methods
+
+### .addMesh( mesh : Mesh, mass : number, restitution : number )
+
+Adds the given mesh to this physics simulation.
+
+**mesh**
+
+The mesh to add.
+
+**mass**
+
+The mass in kg of the mesh.
+
+Default is `0`.
+
+**restitution**
+
+The restitution of the mesh, usually from 0 to 1. Represents how "bouncy" objects are when they collide with each other.
+
+Default is `0`.
+
+### .addScene( scene : Object3D )
+
+Adds the given scene to this physics simulation. Only meshes with a `physics` object in their [Object3D#userData](Object3D.html#userData) field will be honored. The object can be used to store the mass and restitution of the mesh. E.g.:
+
+```js
+box.userData.physics = { mass: 1, restitution: 0 };
+```
+
+**scene**
+
+The scene or any type of 3D object to add.
+
+### .setMeshPosition( mesh : Mesh, position : Vector3, index : number )
+
+Set the position of the given mesh which is part of the physics simulation. Calling this method will reset the current simulated velocity of the mesh.
+
+**mesh**
+
+The mesh to update the position for.
+
+**position**
+
+The new position.
+
+**index**
+
+If the mesh is instanced, the index represents the instanced ID.
+
+Default is `0`.
+
+## Source
+
+[examples/jsm/physics/JoltPhysics.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/physics/JoltPhysics.js)
\ No newline at end of file
diff --git a/docs/pages/KMZLoader.html.md b/docs/pages/KMZLoader.html.md
new file mode 100644
index 00000000000000..6098b02962c81b
--- /dev/null
+++ b/docs/pages/KMZLoader.html.md
@@ -0,0 +1,71 @@
+*Inheritance: Loader →*
+
+# KMZLoader
+
+A loader for the KMZ format.
+
+## Code Example
+
+```js
+const loader = new KMZLoader();
+const kmz = await loader.loadAsync( './models/kmz/Box.kmz' );
+scene.add( kmz.scene );
+```
+
+## Import
+
+KMZLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { KMZLoader } from 'three/addons/loaders/KMZLoader.js';
+```
+
+## Constructor
+
+### new KMZLoader( manager : LoadingManager )
+
+Constructs a new KMZ loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded KMZ asset to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( data : ArrayBuffer ) : Object
+
+Parses the given KMZ data and returns an object holding the scene.
+
+**data**
+
+The raw KMZ data as an array buffer.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** The parsed KMZ asset.
+
+## Source
+
+[examples/jsm/loaders/KMZLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/KMZLoader.js)
\ No newline at end of file
diff --git a/docs/pages/KTX2Exporter.html.md b/docs/pages/KTX2Exporter.html.md
new file mode 100644
index 00000000000000..ab45cb3d7c39b4
--- /dev/null
+++ b/docs/pages/KTX2Exporter.html.md
@@ -0,0 +1,45 @@
+# KTX2Exporter
+
+An exporter for KTX2.
+
+## Code Example
+
+```js
+const exporter = new KTX2Exporter();
+const result = await exporter.parse( dataTexture );
+```
+
+## Import
+
+KTX2Exporter is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { KTX2Exporter } from 'three/addons/exporters/KTX2Exporter.js';
+```
+
+## Constructor
+
+### new KTX2Exporter()
+
+## Methods
+
+### .parse( arg1 : DataTexture | Data3DTexture | WebGPURenderer | WebGLRenderer, arg2 : RenderTarget ) : Promise. (async)
+
+This method has two variants.
+
+* When exporting a data texture, it receives one parameter. The data or 3D data texture.
+* When exporting a render target (e.g. a PMREM), it receives two parameters. The renderer and the render target.
+
+**arg1**
+
+The data texture to export or a renderer.
+
+**arg2**
+
+The render target that should be exported
+
+**Returns:** A Promise that resolves with the exported KTX2.
+
+## Source
+
+[examples/jsm/exporters/KTX2Exporter.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/exporters/KTX2Exporter.js)
\ No newline at end of file
diff --git a/docs/pages/KTX2Loader.html.md b/docs/pages/KTX2Loader.html.md
new file mode 100644
index 00000000000000..a20c003e5fa0ba
--- /dev/null
+++ b/docs/pages/KTX2Loader.html.md
@@ -0,0 +1,140 @@
+*Inheritance: Loader →*
+
+# KTX2Loader
+
+A loader for KTX 2.0 GPU Texture containers.
+
+KTX 2.0 is a container format for various GPU texture formats. The loader supports Basis Universal GPU textures, which can be quickly transcoded to a wide variety of GPU texture compression formats. While KTX 2.0 also allows other hardware-specific formats, this loader does not yet parse them.
+
+This loader parses the KTX 2.0 container and transcodes to a supported GPU compressed texture format. The required WASM transcoder and JS wrapper are available from the `examples/jsm/libs/basis` directory.
+
+This loader relies on Web Assembly which is not supported in older browsers.
+
+References:
+
+* [KTX specification](http://github.khronos.org/KTX-Specification/)
+* [DFD](https://www.khronos.org/registry/DataFormat/specs/1.3/dataformat.1.3.html#basicdescriptor)
+* [BasisU HDR](https://github.com/BinomialLLC/basis_universal/wiki/UASTC-HDR-Texture-Specification-v1.0)
+
+## Code Example
+
+```js
+const loader = new KTX2Loader();
+loader.setTranscoderPath( 'examples/jsm/libs/basis/' );
+loader.detectSupport( renderer );
+const texture = loader.loadAsync( 'diffuse.ktx2' );
+```
+
+## Import
+
+KTX2Loader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { KTX2Loader } from 'three/addons/loaders/KTX2Loader.js';
+```
+
+## Constructor
+
+### new KTX2Loader( manager : LoadingManager )
+
+Constructs a new KTX2 loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .detectSupport( renderer : WebGPURenderer | WebGLRenderer ) : KTX2Loader
+
+Detects hardware support for available compressed texture formats, to determine the output format for the transcoder. Must be called before loading a texture.
+
+**renderer**
+
+The renderer.
+
+**Returns:** A reference to this loader.
+
+### .detectSupportAsync( renderer : WebGPURenderer ) : Promise (async)
+
+Async version of [KTX2Loader#detectSupport](KTX2Loader.html#detectSupport).
+
+**renderer**
+
+The renderer.
+
+**Deprecated:** Yes
+
+**Returns:** A Promise that resolves when the support has been detected.
+
+### .dispose()
+
+Frees internal resources. This method should be called when the loader is no longer required.
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded KTX2 texture to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( buffer : ArrayBuffer, onLoad : function, onError : onErrorCallback ) : Promise
+
+Parses the given KTX2 data.
+
+**buffer**
+
+The raw KTX2 data as an array buffer.
+
+**onLoad**
+
+Executed when the loading/parsing process has been finished.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** A Promise that resolves when the parsing has been finished.
+
+### .setTranscoderPath( path : string ) : KTX2Loader
+
+Sets the transcoder path.
+
+The WASM transcoder and JS wrapper are available from the `examples/jsm/libs/basis` directory.
+
+**path**
+
+The transcoder path to set.
+
+**Returns:** A reference to this loader.
+
+### .setWorkerLimit( workerLimit : number ) : KTX2Loader
+
+Sets the maximum number of Web Workers to be allocated by this instance.
+
+**workerLimit**
+
+The worker limit.
+
+**Returns:** A reference to this loader.
+
+## Source
+
+[examples/jsm/loaders/KTX2Loader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/KTX2Loader.js)
\ No newline at end of file
diff --git a/docs/pages/KTXLoader.html.md b/docs/pages/KTXLoader.html.md
new file mode 100644
index 00000000000000..2d0df2632e118b
--- /dev/null
+++ b/docs/pages/KTXLoader.html.md
@@ -0,0 +1,58 @@
+*Inheritance: Loader → CompressedTextureLoader →*
+
+# KTXLoader
+
+A loader for the KTX texture compression format.
+
+References:
+
+* [The KTX File Format and Tools](https://www.khronos.org/opengles/sdk/tools/KTX/)
+* [Babylon.JS khronosTextureContainer.ts](https://github.com/BabylonJS/Babylon.js/blob/master/src/Misc/khronosTextureContainer.ts)
+
+## Code Example
+
+```js
+const loader = new KTXLoader();
+const map = loader.load( 'textures/compressed/lensflare_ASTC8x8.ktx' )
+map.colorSpace = THREE.SRGBColorSpace; // only for color textures
+```
+
+## Import
+
+KTXLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { KTXLoader } from 'three/addons/loaders/KTXLoader.js';
+```
+
+## Constructor
+
+### new KTXLoader( manager : LoadingManager )
+
+Constructs a new KTX loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .parse( buffer : ArrayBuffer, loadMipmaps : boolean ) : CompressedTextureLoader~TexData
+
+Parses the given KTX texture data.
+
+**buffer**
+
+The raw texture data.
+
+**loadMipmaps**
+
+Whether to load mipmaps or not.
+
+**Overrides:** [CompressedTextureLoader#parse](CompressedTextureLoader.html#parse)
+
+**Returns:** An object representing the parsed texture data.
+
+## Source
+
+[examples/jsm/loaders/KTXLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/KTXLoader.js)
\ No newline at end of file
diff --git a/docs/pages/KeyframeTrack.html.md b/docs/pages/KeyframeTrack.html.md
new file mode 100644
index 00000000000000..389ff318c0db05
--- /dev/null
+++ b/docs/pages/KeyframeTrack.html.md
@@ -0,0 +1,187 @@
+# KeyframeTrack
+
+Represents s a timed sequence of keyframes, which are composed of lists of times and related values, and which are used to animate a specific property of an object.
+
+## Constructor
+
+### new KeyframeTrack( name : string, times : Array., values : Array.<(number|string|boolean)>, interpolation : InterpolateLinear | InterpolateDiscrete | InterpolateSmooth )
+
+Constructs a new keyframe track.
+
+**name**
+
+The keyframe track's name.
+
+**times**
+
+A list of keyframe times.
+
+**values**
+
+A list of keyframe values.
+
+**interpolation**
+
+The interpolation type.
+
+## Properties
+
+### .DefaultInterpolation : InterpolateLinear | InterpolateDiscrete | InterpolateSmooth
+
+The default interpolation type of this keyframe track.
+
+Default is `InterpolateLinear`.
+
+### .TimeBufferType : TypedArray | Array
+
+The time buffer type of this keyframe track.
+
+Default is `Float32Array.constructor`.
+
+### .ValueBufferType : TypedArray | Array
+
+The value buffer type of this keyframe track.
+
+Default is `Float32Array.constructor`.
+
+### .ValueTypeName : string
+
+The value type name.
+
+Default is `''`.
+
+### .name : string
+
+The track's name can refer to morph targets or bones or possibly other values within an animated object. See PropertyBinding#parseTrackName for the forms of strings that can be parsed for property binding.
+
+### .times : Float32Array
+
+The keyframe times.
+
+### .values : Float32Array
+
+The keyframe values.
+
+## Methods
+
+### .InterpolantFactoryMethodDiscrete( result : TypedArray ) : DiscreteInterpolant
+
+Factory method for creating a new discrete interpolant.
+
+**result**
+
+The result buffer.
+
+**Returns:** The new interpolant.
+
+### .InterpolantFactoryMethodLinear( result : TypedArray ) : LinearInterpolant
+
+Factory method for creating a new linear interpolant.
+
+**result**
+
+The result buffer.
+
+**Returns:** The new interpolant.
+
+### .InterpolantFactoryMethodSmooth( result : TypedArray ) : CubicInterpolant
+
+Factory method for creating a new smooth interpolant.
+
+**result**
+
+The result buffer.
+
+**Returns:** The new interpolant.
+
+### .clone() : KeyframeTrack
+
+Returns a new keyframe track with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .getInterpolation() : InterpolateLinear | InterpolateDiscrete | InterpolateSmooth
+
+Returns the current interpolation type.
+
+**Returns:** The interpolation type.
+
+### .getValueSize() : number
+
+Returns the value size.
+
+**Returns:** The value size.
+
+### .optimize() : AnimationClip
+
+Optimizes this keyframe track by removing equivalent sequential keys (which are common in morph target sequences).
+
+**Returns:** A reference to this animation clip.
+
+### .scale( timeScale : number ) : KeyframeTrack
+
+Scale all keyframe times by a factor (useful for frame - seconds conversions).
+
+**timeScale**
+
+The time scale.
+
+**Returns:** A reference to this keyframe track.
+
+### .setInterpolation( interpolation : InterpolateLinear | InterpolateDiscrete | InterpolateSmooth ) : KeyframeTrack
+
+Defines the interpolation factor method for this keyframe track.
+
+**interpolation**
+
+The interpolation type.
+
+**Returns:** A reference to this keyframe track.
+
+### .shift( timeOffset : number ) : KeyframeTrack
+
+Moves all keyframes either forward or backward in time.
+
+**timeOffset**
+
+The offset to move the time values.
+
+**Returns:** A reference to this keyframe track.
+
+### .trim( startTime : number, endTime : number ) : KeyframeTrack
+
+Removes keyframes before and after animation without changing any values within the defined time range.
+
+Note: The method does not shift around keys to the start of the track time, because for interpolated keys this will change their values
+
+**startTime**
+
+The start time.
+
+**endTime**
+
+The end time.
+
+**Returns:** A reference to this keyframe track.
+
+### .validate() : boolean
+
+Performs minimal validation on the keyframe track. Returns `true` if the values are valid.
+
+**Returns:** Whether the keyframes are valid or not.
+
+## Static Methods
+
+### .toJSON( track : KeyframeTrack ) : Object
+
+Converts the keyframe track to JSON.
+
+**track**
+
+The keyframe track to serialize.
+
+**Returns:** The serialized keyframe track as JSON.
+
+## Source
+
+[src/animation/KeyframeTrack.js](https://github.com/mrdoob/three.js/blob/master/src/animation/KeyframeTrack.js)
\ No newline at end of file
diff --git a/docs/pages/KnotCurve.html.md b/docs/pages/KnotCurve.html.md
new file mode 100644
index 00000000000000..405b82ac940bc4
--- /dev/null
+++ b/docs/pages/KnotCurve.html.md
@@ -0,0 +1,39 @@
+*Inheritance: Curve →*
+
+# KnotCurve
+
+A knot curve.
+
+## Import
+
+KnotCurve is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { KnotCurve } from 'three/addons/curves/CurveExtras.js';
+```
+
+## Constructor
+
+### new KnotCurve()
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector3 ) : Vector3
+
+This method returns a vector in 3D space for the given interpolation factor.
+
+**t**
+
+A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the curve.
+
+## Source
+
+[examples/jsm/curves/CurveExtras.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/curves/CurveExtras.js)
\ No newline at end of file
diff --git a/docs/pages/LDrawConditionalLineMaterial.html.md b/docs/pages/LDrawConditionalLineMaterial.html.md
new file mode 100644
index 00000000000000..c3c9d1190f6212
--- /dev/null
+++ b/docs/pages/LDrawConditionalLineMaterial.html.md
@@ -0,0 +1,51 @@
+*Inheritance: EventDispatcher → Material → ShaderMaterial →*
+
+# LDrawConditionalLineMaterial
+
+A special line material for meshes loaded via [LDrawLoader](LDrawLoader.html).
+
+This module can only be used with [WebGLRenderer](WebGLRenderer.html). When using [WebGPURenderer](WebGPURenderer.html), import the class from `LDrawConditionalLineNodeMaterial.js`.
+
+## Import
+
+LDrawConditionalLineMaterial is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { LDrawConditionalLineMaterial } from 'three/addons/materials/LDrawConditionalLineMaterial.js';
+```
+
+## Constructor
+
+### new LDrawConditionalLineMaterial( parameters : Object )
+
+Constructs a new conditional line material.
+
+**parameters**
+
+An object with one or more properties defining the material's appearance. Any property of the material (including any property from inherited materials) can be passed in here. Color values can be passed any type of value accepted by [Color#set](Color.html#set).
+
+## Properties
+
+### .color : Color
+
+The material's color.
+
+Default is `(1,1,1)`.
+
+### .isLDrawConditionalLineMaterial : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .opacity : number
+
+The material's opacity.
+
+Default is `1`.
+
+**Overrides:** [ShaderMaterial#opacity](ShaderMaterial.html#opacity)
+
+## Source
+
+[examples/jsm/materials/LDrawConditionalLineMaterial.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/materials/LDrawConditionalLineMaterial.js)
\ No newline at end of file
diff --git a/docs/pages/LDrawLoader.html.md b/docs/pages/LDrawLoader.html.md
new file mode 100644
index 00000000000000..5ebb127cb1b44a
--- /dev/null
+++ b/docs/pages/LDrawLoader.html.md
@@ -0,0 +1,199 @@
+*Inheritance: Loader →*
+
+# LDrawLoader
+
+A loader for the LDraw format.
+
+\[LDraw\](https://ldraw.org/} (LEGO Draw) is an [open format specification](https://ldraw.org/article/218.html) for describing LEGO and other construction set 3D models.
+
+An LDraw asset (a text file usually with extension .ldr, .dat or .txt) can describe just a single construction piece, or an entire model. In the case of a model the LDraw file can reference other LDraw files, which are loaded from a library path set with `setPartsLibraryPath`. You usually download the LDraw official parts library, extract to a folder and point setPartsLibraryPath to it.
+
+Library parts will be loaded by trial and error in subfolders 'parts', 'p' and 'models'. These file accesses are not optimal for web environment, so a script tool has been made to pack an LDraw file with all its dependencies into a single file, which loads much faster. See section 'Packing LDraw models'. The LDrawLoader example loads several packed files. The official parts library is not included due to its large size.
+
+`LDrawLoader` supports the following extensions:
+
+* !COLOUR: Color and surface finish declarations.
+* BFC: Back Face Culling specification.
+* !CATEGORY: Model/part category declarations.
+* !KEYWORDS: Model/part keywords declarations.
+
+## Code Example
+
+```js
+const loader = new LDrawLoader();
+loader.setConditionalLineMaterial( LDrawConditionalLineMaterial ); // the type of line material depends on the used renderer
+const object = await loader.loadAsync( 'models/ldraw/officialLibrary/models/car.ldr_Packed.mpd' );
+scene.add( object );
+```
+
+## Import
+
+LDrawLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { LDrawLoader } from 'three/addons/loaders/LDrawLoader.js';
+```
+
+## Constructor
+
+### new LDrawLoader( manager : LoadingManager )
+
+Constructs a new LDraw loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .addDefaultMaterials() : LDrawLoader
+
+Initializes the loader with default materials.
+
+**Returns:** A reference to this loader.
+
+### .addMaterial( material : Material ) : LDrawLoader
+
+Adds a single material to the loader's material library.
+
+**material**
+
+The material to add.
+
+**Returns:** A reference to this loader.
+
+### .addMaterials( materials : Array. ) : LDrawLoader
+
+Adds a list of materials to the loader's material library.
+
+**materials**
+
+The materials to add.
+
+**Returns:** A reference to this loader.
+
+### .clearMaterials() : LDrawLoader
+
+Clears the loader's material library.
+
+**Returns:** A reference to this loader.
+
+### .getMainEdgeMaterial() : Material
+
+Returns the material for the edges main LDraw color.
+
+**Returns:** The material. Returns `null` if no material has been found.
+
+### .getMainMaterial() : Material
+
+Returns the Material for the main LDraw color.
+
+For an already loaded LDraw asset, returns the Material associated with the main color code. This method can be useful to modify the main material of a model or part that exposes it.
+
+The main color code is the standard way to color an LDraw part. It is '16' for triangles and '24' for edges. Usually a complete model will not expose the main color (that is, no part uses the code '16' at the top level, because they are assigned other specific colors) An LDraw part file on the other hand will expose the code '16' to be colored, and can have additional fixed colors.
+
+**Returns:** The material. Returns `null` if no material has been found.
+
+### .getMaterial( colorCode : string ) : Material
+
+Returns a material for the given color code.
+
+**colorCode**
+
+The color code.
+
+**Returns:** The material. Returns `null` if no material has been found.
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded LDraw asset to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( text : string, onLoad : function, onError : onErrorCallback )
+
+Parses the given LDraw data and returns the resulting group.
+
+**text**
+
+The raw VRML data as a string.
+
+**onLoad**
+
+Executed when the loading/parsing process has been finished.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+### .preloadMaterials( url : string ) : Promise (async)
+
+This async method preloads materials from a single LDraw file. In the official parts library there is a special file which is loaded always the first (LDConfig.ldr) and contains all the standard color codes. This method is intended to be used with not packed files, for example in an editor where materials are preloaded and parts are loaded on demand.
+
+**url**
+
+Path of the LDraw materials asset.
+
+**Returns:** A Promise that resolves when the preload has finished.
+
+### .setConditionalLineMaterial( type : LDrawConditionalLineMaterial.constructor | LDrawConditionalLineNodeMaterial.constructor ) : LDrawLoader
+
+Sets the conditional line material type which depends on the used renderer. Use [LDrawConditionalLineMaterial](LDrawConditionalLineMaterial.html) when using `WebGLRenderer` and LDrawConditionalLineNodeMaterial when using `WebGPURenderer`.
+
+**type**
+
+The conditional line material type.
+
+**Returns:** A reference to this loader.
+
+### .setFileMap( fileMap : Object. ) : LDrawLoader
+
+Sets a map which maps referenced library filenames to new filenames. If a fileMap is not specified (the default), library parts will be accessed by trial and error in subfolders 'parts', 'p' and 'models'.
+
+**fileMap**
+
+The file map to set.
+
+**Returns:** A reference to this loader.
+
+### .setMaterials( materials : Array. ) : LDrawLoader
+
+Sets the loader's material library. This method clears existing material definitions.
+
+**materials**
+
+The materials to set.
+
+**Returns:** A reference to this loader.
+
+### .setPartsLibraryPath( path : string ) : LDrawLoader
+
+This method must be called prior to `load()` unless the model to load does not reference library parts (usually it will be a model with all its parts packed in a single file).
+
+**path**
+
+Path to library parts files to load referenced parts from. This is different from Loader.setPath, which indicates the path to load the main asset from.
+
+**Returns:** A reference to this loader.
+
+## Source
+
+[examples/jsm/loaders/LDrawLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/LDrawLoader.js)
\ No newline at end of file
diff --git a/docs/pages/LDrawUtils.html.md b/docs/pages/LDrawUtils.html.md
new file mode 100644
index 00000000000000..666780482857d1
--- /dev/null
+++ b/docs/pages/LDrawUtils.html.md
@@ -0,0 +1,31 @@
+# LDrawUtils
+
+Utility class for LDraw models.
+
+## Import
+
+LDrawUtils is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { LDrawUtils } from 'three/addons/utils/LDrawUtils.js';
+```
+
+## Constructor
+
+### new LDrawUtils()
+
+## Static Methods
+
+### .mergeObject( object : Object3D ) : Group
+
+Merges geometries in the given object by materials and returns a new group object. Use on not indexed geometries. The object buffers reference the old object ones. Special treatment is done to the conditional lines generated by LDrawLoader.
+
+**object**
+
+The object to merge.
+
+**Returns:** The merged object.
+
+## Source
+
+[examples/jsm/utils/LDrawUtils.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/utils/LDrawUtils.js)
\ No newline at end of file
diff --git a/docs/pages/LOD.html.md b/docs/pages/LOD.html.md
new file mode 100644
index 00000000000000..36bdc6a26c3e66
--- /dev/null
+++ b/docs/pages/LOD.html.md
@@ -0,0 +1,121 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# LOD
+
+A component for providing a basic Level of Detail (LOD) mechanism.
+
+Every LOD level is associated with an object, and rendering can be switched between them at the distances specified. Typically you would create, say, three meshes, one for far away (low detail), one for mid range (medium detail) and one for close up (high detail).
+
+## Code Example
+
+```js
+const lod = new THREE.LOD();
+const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
+//Create spheres with 3 levels of detail and create new LOD levels for them
+for( let i = 0; i < 3; i++ ) {
+ const geometry = new THREE.IcosahedronGeometry( 10, 3 - i );
+ const mesh = new THREE.Mesh( geometry, material );
+ lod.addLevel( mesh, i * 75 );
+}
+scene.add( lod );
+```
+
+## Constructor
+
+### new LOD()
+
+Constructs a new LOD.
+
+## Properties
+
+### .autoUpdate : boolean
+
+Whether the LOD object is updated automatically by the renderer per frame or not. If set to `false`, you have to call [LOD#update](LOD.html#update) in the render loop by yourself.
+
+Default is `true`.
+
+### .isLOD : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .levels : Array.<{object:Object3D, distance:number, hysteresis:number}>
+
+This array holds the LOD levels.
+
+## Methods
+
+### .addLevel( object : Object3D, distance : number, hysteresis : number ) : LOD
+
+Adds a mesh that will display at a certain distance and greater. Typically the further away the distance, the lower the detail on the mesh.
+
+**object**
+
+The 3D object to display at this level.
+
+**distance**
+
+The distance at which to display this level of detail.
+
+Default is `0`.
+
+**hysteresis**
+
+Threshold used to avoid flickering at LOD boundaries, as a fraction of distance.
+
+Default is `0`.
+
+**Returns:** A reference to this instance.
+
+### .getCurrentLevel() : number
+
+Returns the currently active LOD level index.
+
+**Returns:** The current active LOD level index.
+
+### .getObjectForDistance( distance : number ) : Object3D
+
+Returns a reference to the first 3D object that is greater than the given distance.
+
+**distance**
+
+The LOD distance.
+
+**Returns:** The found 3D object. `null` if no 3D object has been found.
+
+### .raycast( raycaster : Raycaster, intersects : Array. )
+
+Computes intersection points between a casted ray and this LOD.
+
+**raycaster**
+
+The raycaster.
+
+**intersects**
+
+The target array that holds the intersection points.
+
+**Overrides:** [Object3D#raycast](Object3D.html#raycast)
+
+### .removeLevel( distance : number ) : boolean
+
+Removes an existing level, based on the distance from the camera. Returns `true` when the level has been removed. Otherwise `false`.
+
+**distance**
+
+Distance of the level to remove.
+
+**Returns:** Whether the level has been removed or not.
+
+### .update( camera : Camera )
+
+Updates the LOD by computing which LOD level should be visible according to the current distance of the given camera.
+
+**camera**
+
+The camera the scene is rendered with.
+
+## Source
+
+[src/objects/LOD.js](https://github.com/mrdoob/three.js/blob/master/src/objects/LOD.js)
\ No newline at end of file
diff --git a/docs/pages/LUT3dlLoader.html.md b/docs/pages/LUT3dlLoader.html.md
new file mode 100644
index 00000000000000..95b369de487b37
--- /dev/null
+++ b/docs/pages/LUT3dlLoader.html.md
@@ -0,0 +1,97 @@
+*Inheritance: Loader →*
+
+# LUT3dlLoader
+
+A loader for the 3DL LUT format.
+
+References:
+
+* [3D LUTs](http://download.autodesk.com/us/systemdocs/help/2011/lustre/index.html?url=./files/WSc4e151a45a3b785a24c3d9a411df9298473-7ffd.htm,topicNumber=d0e9492)
+* [Format Spec for .3dl](https://community.foundry.com/discuss/topic/103636/format-spec-for-3dl?mode=Post&postID=895258)
+
+## Code Example
+
+```js
+const loader = new LUT3dlLoader();
+const map = loader.loadAsync( 'luts/Presetpro-Cinematic.3dl' );
+```
+
+## Import
+
+LUT3dlLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { LUT3dlLoader } from 'three/addons/loaders/LUT3dlLoader.js';
+```
+
+## Constructor
+
+### new LUT3dlLoader( manager : LoadingManager )
+
+Constructs a new 3DL LUT loader.
+
+**manager**
+
+The loading manager.
+
+## Classes
+
+[LUT3dlLoader](LUT3dlLoader.html)
+
+## Properties
+
+### .type : UnsignedByteType | FloatType
+
+The texture type.
+
+Default is `UnsignedByteType`.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded 3DL LUT asset to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( input : string ) : Object
+
+Parses the given 3DL LUT data and returns the resulting 3D data texture.
+
+**input**
+
+The raw 3DL LUT data as a string.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** The parsed 3DL LUT.
+
+### .setType( type : UnsignedByteType | FloatType ) : LUT3dlLoader
+
+Sets the texture type.
+
+**type**
+
+The texture type to set.
+
+**Returns:** A reference to this loader.
+
+## Source
+
+[examples/jsm/loaders/LUT3dlLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/LUT3dlLoader.js)
\ No newline at end of file
diff --git a/docs/pages/LUTCubeLoader.html.md b/docs/pages/LUTCubeLoader.html.md
new file mode 100644
index 00000000000000..8677cf013df83c
--- /dev/null
+++ b/docs/pages/LUTCubeLoader.html.md
@@ -0,0 +1,96 @@
+*Inheritance: Loader →*
+
+# LUTCubeLoader
+
+A loader for the Cube LUT format.
+
+References:
+
+* [Cube LUT Specification](https://web.archive.org/web/20220220033515/https://wwwimages2.adobe.com/content/dam/acom/en/products/speedgrade/cc/pdfs/cube-lut-specification-1.0.pdf)
+
+## Code Example
+
+```js
+const loader = new LUTCubeLoader();
+const map = loader.loadAsync( 'luts/Bourbon 64.CUBE' );
+```
+
+## Import
+
+LUTCubeLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { LUTCubeLoader } from 'three/addons/loaders/LUTCubeLoader.js';
+```
+
+## Constructor
+
+### new LUTCubeLoader( manager : LoadingManager )
+
+Constructs a new Cube LUT loader.
+
+**manager**
+
+The loading manager.
+
+## Classes
+
+[LUTCubeLoader](LUTCubeLoader.html)
+
+## Properties
+
+### .type : UnsignedByteType | FloatType
+
+The texture type.
+
+Default is `UnsignedByteType`.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded Cube LUT asset to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( input : string ) : Object
+
+Parses the given Cube LUT data and returns the resulting 3D data texture.
+
+**input**
+
+The raw Cube LUT data as a string.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** The parsed Cube LUT.
+
+### .setType( type : UnsignedByteType | FloatType ) : LUTCubeLoader
+
+Sets the texture type.
+
+**type**
+
+The texture type to set.
+
+**Returns:** A reference to this loader.
+
+## Source
+
+[examples/jsm/loaders/LUTCubeLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/LUTCubeLoader.js)
\ No newline at end of file
diff --git a/docs/pages/LUTImageLoader.html.md b/docs/pages/LUTImageLoader.html.md
new file mode 100644
index 00000000000000..e165130ed14b58
--- /dev/null
+++ b/docs/pages/LUTImageLoader.html.md
@@ -0,0 +1,88 @@
+*Inheritance: Loader →*
+
+# LUTImageLoader
+
+A loader for loading LUT images.
+
+## Code Example
+
+```js
+const loader = new LUTImageLoader();
+const map = loader.loadAsync( 'luts/NeutralLUT.png' );
+```
+
+## Import
+
+LUTImageLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { LUTImageLoader } from 'three/addons/loaders/LUTImageLoader.js';
+```
+
+## Constructor
+
+### new LUTImageLoader( manager : LoadingManager )
+
+Constructs a new LUT loader.
+
+**manager**
+
+The loading manager.
+
+## Classes
+
+[LUTImageLoader](LUTImageLoader.html)
+
+## Properties
+
+### .flip : boolean
+
+Whether to vertically flip the LUT or not.
+
+Depending on the LUT's origin, the texture has green at the bottom (e.g. for Unreal) or green at the top (e.g. for Unity URP Color Lookup). If you're using lut image strips from a Unity pipeline, then set this property to `true`.
+
+Default is `false`.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded LUT to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( dataArray : Uint8ClampedArray, size : number ) : Object
+
+Parses the given LUT data and returns the resulting 3D data texture.
+
+**dataArray**
+
+The raw LUT data.
+
+**size**
+
+The LUT size.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** An object representing the parsed LUT.
+
+## Source
+
+[examples/jsm/loaders/LUTImageLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/LUTImageLoader.js)
\ No newline at end of file
diff --git a/docs/pages/LUTPass.html.md b/docs/pages/LUTPass.html.md
new file mode 100644
index 00000000000000..595bbb3376dabb
--- /dev/null
+++ b/docs/pages/LUTPass.html.md
@@ -0,0 +1,50 @@
+*Inheritance: Pass → ShaderPass →*
+
+# LUTPass
+
+Pass for color grading via lookup tables.
+
+## Code Example
+
+```js
+const lutPass = new LUTPass( { lut: lut.texture3D } );
+composer.addPass( lutPass );
+```
+
+## Import
+
+LUTPass is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { LUTPass } from 'three/addons/postprocessing/LUTPass.js';
+```
+
+## Constructor
+
+### new LUTPass( options : Object )
+
+Constructs a LUT pass.
+
+**options**
+
+The pass options.
+
+Default is `{}`.
+
+## Properties
+
+### .intensity : number
+
+The intensity.
+
+Default is `1`.
+
+### .lut : Data3DTexture
+
+The LUT as a 3D texture.
+
+Default is `null`.
+
+## Source
+
+[examples/jsm/postprocessing/LUTPass.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/postprocessing/LUTPass.js)
\ No newline at end of file
diff --git a/docs/pages/LWOLoader.html.md b/docs/pages/LWOLoader.html.md
new file mode 100644
index 00000000000000..fa8cc1f439d8c3
--- /dev/null
+++ b/docs/pages/LWOLoader.html.md
@@ -0,0 +1,87 @@
+*Inheritance: Loader →*
+
+# LWOLoader
+
+A loader for the LWO format.
+
+LWO3 and LWO2 formats are supported.
+
+References:
+
+* [LWO3 format specification](https://static.lightwave3d.com/sdk/2019/html/filefmts/lwo3.html)
+* [LWO2 format specification](https://static.lightwave3d.com/sdk/2019/html/filefmts/lwo2.html)
+
+## Code Example
+
+```js
+const loader = new LWOLoader();
+const lwoData = await loader.loadAsync( 'models/lwo/Objects/LWO3/Demo.lwo' );
+const mesh = object.meshes[ 0 ];
+scene.add( mesh );
+```
+
+## Import
+
+LWOLoader is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { LWOLoader } from 'three/addons/loaders/LWOLoader.js';
+```
+
+## Constructor
+
+### new LWOLoader( manager : LoadingManager )
+
+Constructs a new LWO loader.
+
+**manager**
+
+The loading manager.
+
+## Methods
+
+### .load( url : string, onLoad : function, onProgress : onProgressCallback, onError : onErrorCallback )
+
+Starts loading from the given URL and passes the loaded LWO asset to the `onLoad()` callback.
+
+**url**
+
+The path/URL of the file to be loaded. This can also be a data URI.
+
+**onLoad**
+
+Executed when the loading process has been finished.
+
+**onProgress**
+
+Executed while the loading is in progress.
+
+**onError**
+
+Executed when errors occur.
+
+**Overrides:** [Loader#load](Loader.html#load)
+
+### .parse( iffBuffer : ArrayBuffer, path : string, modelName : string ) : Object
+
+Parses the given LWO data and returns the resulting meshes and materials.
+
+**iffBuffer**
+
+The raw LWO data as an array buffer.
+
+**path**
+
+The URL base path.
+
+**modelName**
+
+The model name.
+
+**Overrides:** [Loader#parse](Loader.html#parse)
+
+**Returns:** An object holding the parse meshes and materials.
+
+## Source
+
+[examples/jsm/loaders/LWOLoader.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/LWOLoader.js)
\ No newline at end of file
diff --git a/docs/pages/LatheGeometry.html.md b/docs/pages/LatheGeometry.html.md
new file mode 100644
index 00000000000000..09b6ac4dbcf82d
--- /dev/null
+++ b/docs/pages/LatheGeometry.html.md
@@ -0,0 +1,68 @@
+*Inheritance: EventDispatcher → BufferGeometry →*
+
+# LatheGeometry
+
+Creates meshes with axial symmetry like vases. The lathe rotates around the Y axis.
+
+## Code Example
+
+```js
+const points = [];
+for ( let i = 0; i < 10; i ++ ) {
+ points.push( new THREE.Vector2( Math.sin( i * 0.2 ) * 10 + 5, ( i - 5 ) * 2 ) );
+}
+const geometry = new THREE.LatheGeometry( points );
+const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
+const lathe = new THREE.Mesh( geometry, material );
+scene.add( lathe );
+```
+
+## Constructor
+
+### new LatheGeometry( points : Array.<(Vector2|Vector3)>, segments : number, phiStart : number, phiLength : number )
+
+Constructs a new lathe geometry.
+
+**points**
+
+An array of points in 2D space. The x-coordinate of each point must be greater than zero.
+
+**segments**
+
+The number of circumference segments to generate.
+
+Default is `12`.
+
+**phiStart**
+
+The starting angle in radians.
+
+Default is `0`.
+
+**phiLength**
+
+The radian (0 to 2PI) range of the lathed section 2PI is a closed lathe, less than 2PI is a portion.
+
+Default is `Math.PI*2`.
+
+## Properties
+
+### .parameters : Object
+
+Holds the constructor parameters that have been used to generate the geometry. Any modification after instantiation does not change the geometry.
+
+## Static Methods
+
+### .fromJSON( data : Object ) : LatheGeometry
+
+Factory method for creating an instance of this class from the given JSON object.
+
+**data**
+
+A JSON object representing the serialized geometry.
+
+**Returns:** A new instance.
+
+## Source
+
+[src/geometries/LatheGeometry.js](https://github.com/mrdoob/three.js/blob/master/src/geometries/LatheGeometry.js)
\ No newline at end of file
diff --git a/docs/pages/Layers.html.md b/docs/pages/Layers.html.md
new file mode 100644
index 00000000000000..28caa7e53c424f
--- /dev/null
+++ b/docs/pages/Layers.html.md
@@ -0,0 +1,85 @@
+# Layers
+
+A layers object assigns an 3D object to 1 or more of 32 layers numbered `0` to `31` - internally the layers are stored as a bit mask\], and by default all 3D objects are a member of layer `0`.
+
+This can be used to control visibility - an object must share a layer with a camera to be visible when that camera's view is rendered.
+
+All classes that inherit from [Object3D](Object3D.html) have an `layers` property which is an instance of this class.
+
+## Constructor
+
+### new Layers()
+
+Constructs a new layers instance, with membership initially set to layer `0`.
+
+## Properties
+
+### .mask : number
+
+A bit mask storing which of the 32 layers this layers object is currently a member of.
+
+## Methods
+
+### .disable( layer : number )
+
+Removes membership of the given layer.
+
+**layer**
+
+The layer to enable.
+
+### .disableAll()
+
+Removes the membership from all layers.
+
+### .enable( layer : number )
+
+Adds membership of the given layer.
+
+**layer**
+
+The layer to enable.
+
+### .enableAll()
+
+Adds membership to all layers.
+
+### .isEnabled( layer : number ) : boolean
+
+Returns `true` if the given layer is enabled.
+
+**layer**
+
+The layer to test.
+
+**Returns:** Whether the given layer is enabled or not.
+
+### .set( layer : number )
+
+Sets membership to the given layer, and remove membership all other layers.
+
+**layer**
+
+The layer to set.
+
+### .test( layers : Layers ) : boolean
+
+Returns `true` if this and the given layers object have at least one layer in common.
+
+**layers**
+
+The layers to test.
+
+**Returns:** Whether this and the given layers object have at least one layer in common or not.
+
+### .toggle( layer : number )
+
+Toggles the membership of the given layer.
+
+**layer**
+
+The layer to toggle.
+
+## Source
+
+[src/core/Layers.js](https://github.com/mrdoob/three.js/blob/master/src/core/Layers.js)
\ No newline at end of file
diff --git a/docs/pages/Lensflare.html.md b/docs/pages/Lensflare.html.md
new file mode 100644
index 00000000000000..1f552320f7ee04
--- /dev/null
+++ b/docs/pages/Lensflare.html.md
@@ -0,0 +1,74 @@
+*Inheritance: EventDispatcher → Object3D → Mesh →*
+
+# Lensflare
+
+Creates a simulated lens flare that tracks a light.
+
+Note that this class can only be used with [WebGLRenderer](WebGLRenderer.html). When using [WebGPURenderer](WebGPURenderer.html), use [LensflareMesh](LensflareMesh.html).
+
+## Code Example
+
+```js
+const light = new THREE.PointLight( 0xffffff, 1.5, 2000 );
+const lensflare = new Lensflare();
+lensflare.addElement( new LensflareElement( textureFlare0, 512, 0 ) );
+lensflare.addElement( new LensflareElement( textureFlare1, 512, 0 ) );
+lensflare.addElement( new LensflareElement( textureFlare2, 60, 0.6 ) );
+light.add( lensflare );
+```
+
+## Import
+
+Lensflare is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { Lensflare } from 'three/addons/objects/Lensflare.js';
+```
+
+## Constructor
+
+### new Lensflare()
+
+Constructs a new lensflare.
+
+## Properties
+
+### .frustumCulled : boolean
+
+Overwritten to disable view-frustum culling by default.
+
+Default is `false`.
+
+**Overrides:** [Mesh#frustumCulled](Mesh.html#frustumCulled)
+
+### .isLensflare : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .renderOrder : number
+
+Overwritten to make sure lensflares a rendered last.
+
+Default is `Infinity`.
+
+**Overrides:** [Mesh#renderOrder](Mesh.html#renderOrder)
+
+## Methods
+
+### .addElement( element : LensflareElement )
+
+Adds the given lensflare element to this instance.
+
+**element**
+
+The element to add.
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+## Source
+
+[examples/jsm/objects/Lensflare.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/objects/Lensflare.js)
\ No newline at end of file
diff --git a/docs/pages/LensflareElement.html.md b/docs/pages/LensflareElement.html.md
new file mode 100644
index 00000000000000..d266c784f8202a
--- /dev/null
+++ b/docs/pages/LensflareElement.html.md
@@ -0,0 +1,65 @@
+# LensflareElement
+
+Represents a single flare that can be added to a [Lensflare](Lensflare.html) container.
+
+## Import
+
+LensflareElement is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { LensflareElement } from 'three/addons/objects/Lensflare.js';
+```
+
+## Constructor
+
+### new LensflareElement( texture : Texture, size : number, distance : number, color : Color )
+
+Constructs a new lensflare element.
+
+**texture**
+
+The flare's texture.
+
+**size**
+
+The size in pixels.
+
+Default is `1`.
+
+**distance**
+
+The normalized distance (`[0,1]`) from the light source. A value of `0` means the flare is located at light source.
+
+Default is `0`.
+
+**color**
+
+The flare's color
+
+## Properties
+
+### .color : Color
+
+The flare's color
+
+Default is `(1,1,1)`.
+
+### .distance : number
+
+The normalized distance (`[0,1]`) from the light source. A value of `0` means the flare is located at light source.
+
+Default is `0`.
+
+### .size : number
+
+The size in pixels.
+
+Default is `1`.
+
+### .texture : Texture
+
+The flare's texture.
+
+## Source
+
+[examples/jsm/objects/Lensflare.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/objects/Lensflare.js)
\ No newline at end of file
diff --git a/docs/pages/LensflareMesh.html.md b/docs/pages/LensflareMesh.html.md
new file mode 100644
index 00000000000000..dc510ce6212139
--- /dev/null
+++ b/docs/pages/LensflareMesh.html.md
@@ -0,0 +1,74 @@
+*Inheritance: EventDispatcher → Object3D → Mesh →*
+
+# LensflareMesh
+
+Creates a simulated lens flare that tracks a light.
+
+Note that this class can only be used with [WebGPURenderer](WebGPURenderer.html). When using [WebGLRenderer](WebGLRenderer.html), use [Lensflare](Lensflare.html).
+
+## Code Example
+
+```js
+const light = new THREE.PointLight( 0xffffff, 1.5, 2000 );
+const lensflare = new LensflareMesh();
+lensflare.addElement( new LensflareElement( textureFlare0, 512, 0 ) );
+lensflare.addElement( new LensflareElement( textureFlare1, 512, 0 ) );
+lensflare.addElement( new LensflareElement( textureFlare2, 60, 0.6 ) );
+light.add( lensflare );
+```
+
+## Import
+
+LensflareMesh is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { LensflareMesh } from 'three/addons/objects/LensflareMesh.js';
+```
+
+## Constructor
+
+### new LensflareMesh()
+
+Constructs a new lensflare mesh.
+
+## Properties
+
+### .frustumCulled : boolean
+
+Overwritten to disable view-frustum culling by default.
+
+Default is `false`.
+
+**Overrides:** [Mesh#frustumCulled](Mesh.html#frustumCulled)
+
+### .isLensflareMesh : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .renderOrder : number
+
+Overwritten to make sure lensflares a rendered last.
+
+Default is `Infinity`.
+
+**Overrides:** [Mesh#renderOrder](Mesh.html#renderOrder)
+
+## Methods
+
+### .addElement( element : LensflareElement )
+
+Adds the given lensflare element to this instance.
+
+**element**
+
+The element to add.
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+## Source
+
+[examples/jsm/objects/LensflareMesh.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/objects/LensflareMesh.js)
\ No newline at end of file
diff --git a/docs/pages/LensflareNode.html.md b/docs/pages/LensflareNode.html.md
new file mode 100644
index 00000000000000..23af54562e84b6
--- /dev/null
+++ b/docs/pages/LensflareNode.html.md
@@ -0,0 +1,156 @@
+*Inheritance: EventDispatcher → Node → TempNode →*
+
+# LensflareNode
+
+Post processing node for adding a bloom-based lens flare effect. This effect requires that you extract the bloom of the scene via a bloom pass first.
+
+References:
+
+* [https://john-chapman-graphics.blogspot.com/2013/02/pseudo-lens-flare.html](https://john-chapman-graphics.blogspot.com/2013/02/pseudo-lens-flare.html).
+* [https://john-chapman.github.io/2017/11/05/pseudo-lens-flare.html](https://john-chapman.github.io/2017/11/05/pseudo-lens-flare.html).
+
+## Import
+
+LensflareNode is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { lensflare } from 'three/addons/tsl/display/LensflareNode.js';
+```
+
+## Constructor
+
+### new LensflareNode( textureNode : TextureNode, params : Object )
+
+Constructs a new lens flare node.
+
+**textureNode**
+
+The texture node that represents the scene's bloom.
+
+**params**
+
+The parameter object for configuring the effect.
+
+**ghostTint**
+
+Defines the tint of the flare/ghosts.
+
+Default is `vec3(1, 1, 1)`.
+
+**threshold**
+
+Controls the size and strength of the effect. A higher threshold results in smaller flares.
+
+Default is `float(0.5)`.
+
+**ghostSamples**
+
+Represents the number of flares/ghosts per bright spot which pivot around the center.
+
+Default is `float(4)`.
+
+**ghostSpacing**
+
+Defines the spacing of the flares/ghosts.
+
+Default is `float(0.25)`.
+
+**ghostAttenuationFactor**
+
+Defines the attenuation factor of flares/ghosts.
+
+Default is `float(25)`.
+
+**downSampleRatio**
+
+Defines how downsampling since the effect is usually not rendered at full resolution.
+
+Default is `4`.
+
+## Properties
+
+### .downSampleRatio : number
+
+Defines how downsampling since the effect is usually not rendered at full resolution.
+
+### .ghostAttenuationFactorNode : Node.
+
+Defines the attenuation factor of flares/ghosts.
+
+### .ghostSamplesNode : Node.
+
+Represents the number of flares/ghosts per bright spot which pivot around the center.
+
+### .ghostSpacingNode : Node.
+
+Defines the spacing of the flares/ghosts.
+
+### .ghostTintNode : Node.
+
+Defines the tint of the flare/ghosts.
+
+### .textureNode : TextureNode
+
+The texture node that represents the scene's bloom.
+
+### .thresholdNode : Node.
+
+Controls the size and strength of the effect. A higher threshold results in smaller flares.
+
+### .updateBeforeType : string
+
+The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node renders its effect once per frame in `updateBefore()`.
+
+Default is `'frame'`.
+
+**Overrides:** [TempNode#updateBeforeType](TempNode.html#updateBeforeType)
+
+## Methods
+
+### .dispose()
+
+Frees internal resources. This method should be called when the effect is no longer required.
+
+**Overrides:** [TempNode#dispose](TempNode.html#dispose)
+
+### .getTextureNode() : PassTextureNode
+
+Returns the result of the effect as a texture node.
+
+**Returns:** A texture node that represents the result of the effect.
+
+### .setSize( width : number, height : number )
+
+Sets the size of the effect.
+
+**width**
+
+The width of the effect.
+
+**height**
+
+The height of the effect.
+
+### .setup( builder : NodeBuilder ) : PassTextureNode
+
+This method is used to setup the effect's TSL code.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [TempNode#setup](TempNode.html#setup)
+
+### .updateBefore( frame : NodeFrame )
+
+This method is used to render the effect once per frame.
+
+**frame**
+
+The current node frame.
+
+**Overrides:** [TempNode#updateBefore](TempNode.html#updateBefore)
+
+## Source
+
+[examples/jsm/tsl/display/LensflareNode.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/tsl/display/LensflareNode.js)
\ No newline at end of file
diff --git a/docs/pages/Light.html.md b/docs/pages/Light.html.md
new file mode 100644
index 00000000000000..22a58526cd9c63
--- /dev/null
+++ b/docs/pages/Light.html.md
@@ -0,0 +1,51 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# Light
+
+Abstract base class for lights - all other light types inherit the properties and methods described here.
+
+## Constructor
+
+### new Light( color : number | Color | string, intensity : number ) (abstract)
+
+Constructs a new light.
+
+**color**
+
+The light's color.
+
+Default is `0xffffff`.
+
+**intensity**
+
+The light's strength/intensity.
+
+Default is `1`.
+
+## Properties
+
+### .color : Color
+
+The light's color.
+
+### .intensity : number
+
+The light's intensity.
+
+Default is `1`.
+
+### .isLight : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+## Source
+
+[src/lights/Light.js](https://github.com/mrdoob/three.js/blob/master/src/lights/Light.js)
\ No newline at end of file
diff --git a/docs/pages/LightProbe.html.md b/docs/pages/LightProbe.html.md
new file mode 100644
index 00000000000000..7440063bc1d82c
--- /dev/null
+++ b/docs/pages/LightProbe.html.md
@@ -0,0 +1,41 @@
+*Inheritance: EventDispatcher → Object3D → Light →*
+
+# LightProbe
+
+Light probes are an alternative way of adding light to a 3D scene. Unlike classical light sources (e.g. directional, point or spot lights), light probes do not emit light. Instead they store information about light passing through 3D space. During rendering, the light that hits a 3D object is approximated by using the data from the light probe.
+
+Light probes are usually created from (radiance) environment maps. The class [LightProbeGenerator](LightProbeGenerator.html) can be used to create light probes from cube textures or render targets. However, light estimation data could also be provided in other forms e.g. by WebXR. This enables the rendering of augmented reality content that reacts to real world lighting.
+
+The current probe implementation in three.js supports so-called diffuse light probes. This type of light probe is functionally equivalent to an irradiance environment map.
+
+## Constructor
+
+### new LightProbe( sh : SphericalHarmonics3, intensity : number )
+
+Constructs a new light probe.
+
+**sh**
+
+The spherical harmonics which represents encoded lighting information.
+
+**intensity**
+
+The light's strength/intensity.
+
+Default is `1`.
+
+## Properties
+
+### .isLightProbe : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .sh : SphericalHarmonics3
+
+A light probe uses spherical harmonics to encode lighting information.
+
+## Source
+
+[src/lights/LightProbe.js](https://github.com/mrdoob/three.js/blob/master/src/lights/LightProbe.js)
\ No newline at end of file
diff --git a/docs/pages/LightProbeGenerator.html.md b/docs/pages/LightProbeGenerator.html.md
new file mode 100644
index 00000000000000..1f8dd74187f4d0
--- /dev/null
+++ b/docs/pages/LightProbeGenerator.html.md
@@ -0,0 +1,43 @@
+# LightProbeGenerator
+
+Utility class for creating instances of [LightProbe](LightProbe.html).
+
+## Import
+
+LightProbeGenerator is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { LightProbeGenerator } from 'three/addons/lights/LightProbeGenerator.js';
+```
+
+## Static Methods
+
+### .fromCubeRenderTarget( renderer : WebGPURenderer | WebGLRenderer, cubeRenderTarget : CubeRenderTarget | WebGLCubeRenderTarget ) : Promise. (async)
+
+Creates a light probe from the given (radiance) environment map. The method expects that the environment map is represented as a cube render target.
+
+The cube render target must be in RGBA so `cubeRenderTarget.texture.format` must be set to [RGBAFormat](global.html#RGBAFormat).
+
+**renderer**
+
+The renderer.
+
+**cubeRenderTarget**
+
+The environment map.
+
+**Returns:** A Promise that resolves with the created light probe.
+
+### .fromCubeTexture( cubeTexture : CubeTexture ) : LightProbe
+
+Creates a light probe from the given (radiance) environment map. The method expects that the environment map is represented as a cube texture.
+
+**cubeTexture**
+
+The environment map.
+
+**Returns:** The created light probe.
+
+## Source
+
+[examples/jsm/lights/LightProbeGenerator.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/lights/LightProbeGenerator.js)
\ No newline at end of file
diff --git a/docs/pages/LightProbeHelper.html.md b/docs/pages/LightProbeHelper.html.md
new file mode 100644
index 00000000000000..47e6304c4bf365
--- /dev/null
+++ b/docs/pages/LightProbeHelper.html.md
@@ -0,0 +1,60 @@
+*Inheritance: EventDispatcher → Object3D → Mesh →*
+
+# LightProbeHelper
+
+Renders a sphere to visualize a light probe in the scene.
+
+This helper can only be used with [WebGLRenderer](WebGLRenderer.html). When using [WebGPURenderer](WebGPURenderer.html), import from `LightProbeHelperGPU.js`.
+
+## Code Example
+
+```js
+const helper = new LightProbeHelper( lightProbe );
+scene.add( helper );
+```
+
+## Import
+
+LightProbeHelper is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { LightProbeHelper } from 'three/addons/helpers/LightProbeHelper.js';
+```
+
+## Constructor
+
+### new LightProbeHelper( lightProbe : LightProbe, size : number )
+
+Constructs a new light probe helper.
+
+**lightProbe**
+
+The light probe to visualize.
+
+**size**
+
+The size of the helper.
+
+Default is `1`.
+
+## Properties
+
+### .lightProbe : LightProbe
+
+The light probe to visualize.
+
+### .size : number
+
+The size of the helper.
+
+Default is `1`.
+
+## Methods
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+## Source
+
+[examples/jsm/helpers/LightProbeHelper.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/helpers/LightProbeHelper.js)
\ No newline at end of file
diff --git a/docs/pages/LightProbeNode.html.md b/docs/pages/LightProbeNode.html.md
new file mode 100644
index 00000000000000..1b4c61a6650a79
--- /dev/null
+++ b/docs/pages/LightProbeNode.html.md
@@ -0,0 +1,39 @@
+*Inheritance: EventDispatcher → Node → LightingNode → AnalyticLightNode →*
+
+# LightProbeNode
+
+Module for representing light probes as nodes.
+
+## Constructor
+
+### new LightProbeNode( light : LightProbe )
+
+Constructs a new light probe node.
+
+**light**
+
+The light probe.
+
+Default is `null`.
+
+## Properties
+
+### .lightProbe : UniformArrayNode
+
+Light probe represented as a uniform of spherical harmonics.
+
+## Methods
+
+### .update( frame : NodeFrame )
+
+Overwritten to updated light probe specific uniforms.
+
+**frame**
+
+A reference to the current node frame.
+
+**Overrides:** [AnalyticLightNode#update](AnalyticLightNode.html#update)
+
+## Source
+
+[src/nodes/lighting/LightProbeNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/lighting/LightProbeNode.js)
\ No newline at end of file
diff --git a/docs/pages/LightShadow.html.md b/docs/pages/LightShadow.html.md
new file mode 100644
index 00000000000000..16a950f3e9d0a4
--- /dev/null
+++ b/docs/pages/LightShadow.html.md
@@ -0,0 +1,165 @@
+# LightShadow
+
+Abstract base class for light shadow classes. These classes represent the shadow configuration for different light types.
+
+## Constructor
+
+### new LightShadow( camera : Camera ) (abstract)
+
+Constructs a new light shadow.
+
+**camera**
+
+The light's view of the world.
+
+## Properties
+
+### .autoUpdate : boolean
+
+Enables automatic updates of the light's shadow. If you do not require dynamic lighting / shadows, you may set this to `false`.
+
+Default is `true`.
+
+### .bias : number
+
+Shadow map bias, how much to add or subtract from the normalized depth when deciding whether a surface is in shadow.
+
+The default is `0`. Very tiny adjustments here (in the order of `0.0001`) may help reduce artifacts in shadows.
+
+Default is `0`.
+
+### .blurSamples : number
+
+The amount of samples to use when blurring a VSM shadow map.
+
+Default is `8`.
+
+### .camera : Camera
+
+The light's view of the world.
+
+### .intensity : number
+
+The intensity of the shadow. The default is `1`. Valid values are in the range `[0, 1]`.
+
+Default is `1`.
+
+### .map : RenderTarget
+
+The depth map generated using the internal camera; a location beyond a pixel's depth is in shadow. Computed internally during rendering.
+
+Default is `null`.
+
+### .mapPass : RenderTarget
+
+The distribution map generated using the internal camera; an occlusion is calculated based on the distribution of depths. Computed internally during rendering.
+
+Default is `null`.
+
+### .mapSize : Vector2
+
+Defines the width and height of the shadow map. Higher values give better quality shadows at the cost of computation time. Values must be powers of two.
+
+Default is `(512,512)`.
+
+### .mapType : number
+
+The type of shadow texture. The default is `UnsignedByteType`.
+
+Default is `UnsignedByteType`.
+
+### .matrix : Matrix4
+
+Model to shadow camera space, to compute location and depth in shadow map. This is computed internally during rendering.
+
+### .needsUpdate : boolean
+
+When set to `true`, shadow maps will be updated in the next `render` call. If you have set [LightShadow#autoUpdate](LightShadow.html#autoUpdate) to `false`, you will need to set this property to `true` and then make a render call to update the light's shadow.
+
+Default is `false`.
+
+### .normalBias : number
+
+Defines how much the position used to query the shadow map is offset along the object normal. The default is `0`. Increasing this value can be used to reduce shadow acne especially in large scenes where light shines onto geometry at a shallow angle. The cost is that shadows may appear distorted.
+
+Default is `0`.
+
+### .radius : number
+
+Setting this to values greater than 1 will blur the edges of the shadow. High values will cause unwanted banding effects in the shadows - a greater map size will allow for a higher value to be used here before these effects become visible.
+
+The property has no effect when the shadow map type is `BasicShadowMap`.
+
+Default is `1`.
+
+## Methods
+
+### .clone() : LightShadow
+
+Returns a new light shadow instance with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .copy( source : LightShadow ) : LightShadow
+
+Copies the values of the given light shadow instance to this instance.
+
+**source**
+
+The light shadow to copy.
+
+**Returns:** A reference to this light shadow instance.
+
+### .dispose()
+
+Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+
+### .getFrameExtents() : Vector2
+
+Returns the frame extends.
+
+**Returns:** The frame extends.
+
+### .getFrustum() : Frustum
+
+Gets the shadow cameras frustum. Used internally by the renderer to cull objects.
+
+**Returns:** The shadow camera frustum.
+
+### .getViewport( viewportIndex : number ) : Vector4
+
+Returns a viewport definition for the given viewport index.
+
+**viewportIndex**
+
+The viewport index.
+
+**Returns:** The viewport.
+
+### .getViewportCount() : number
+
+Used internally by the renderer to get the number of viewports that need to be rendered for this shadow.
+
+**Returns:** The viewport count.
+
+### .toJSON() : Object
+
+Serializes the light shadow into JSON.
+
+See:
+
+* [ObjectLoader#parse](ObjectLoader.html#parse)
+
+**Returns:** A JSON object representing the serialized light shadow.
+
+### .updateMatrices( light : Light )
+
+Update the matrices for the camera and shadow, used internally by the renderer.
+
+**light**
+
+The light for which the shadow is being rendered.
+
+## Source
+
+[src/lights/LightShadow.js](https://github.com/mrdoob/three.js/blob/master/src/lights/LightShadow.js)
\ No newline at end of file
diff --git a/docs/pages/LightingContextNode.html.md b/docs/pages/LightingContextNode.html.md
new file mode 100644
index 00000000000000..c266122542beb2
--- /dev/null
+++ b/docs/pages/LightingContextNode.html.md
@@ -0,0 +1,65 @@
+*Inheritance: EventDispatcher → Node → ContextNode →*
+
+# LightingContextNode
+
+`LightingContextNode` represents an extension of the [ContextNode](ContextNode.html) module by adding lighting specific context data. It represents the runtime context of [LightsNode](LightsNode.html).
+
+## Constructor
+
+### new LightingContextNode( lightsNode : LightsNode, lightingModel : LightingModel, backdropNode : Node., backdropAlphaNode : Node. )
+
+Constructs a new lighting context node.
+
+**lightsNode**
+
+The lights node.
+
+**lightingModel**
+
+The current lighting model.
+
+Default is `null`.
+
+**backdropNode**
+
+A backdrop node.
+
+Default is `null`.
+
+**backdropAlphaNode**
+
+A backdrop alpha node.
+
+Default is `null`.
+
+## Properties
+
+### .backdropAlphaNode : Node.
+
+A backdrop alpha node.
+
+Default is `null`.
+
+### .backdropNode : Node.
+
+A backdrop node.
+
+Default is `null`.
+
+### .lightingModel : LightingModel
+
+The current lighting model.
+
+Default is `null`.
+
+## Methods
+
+### .getContext() : Object
+
+Returns a lighting context object.
+
+**Returns:** The lighting context object.
+
+## Source
+
+[src/nodes/lighting/LightingContextNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/lighting/LightingContextNode.js)
\ No newline at end of file
diff --git a/docs/pages/LightingModel.html.md b/docs/pages/LightingModel.html.md
new file mode 100644
index 00000000000000..da386870399a1f
--- /dev/null
+++ b/docs/pages/LightingModel.html.md
@@ -0,0 +1,69 @@
+# LightingModel
+
+Abstract class for implementing lighting models. The module defines multiple methods that concrete lighting models can implement. These methods are executed at different points during the light evaluation process.
+
+## Constructor
+
+### new LightingModel()
+
+## Methods
+
+### .ambientOcclusion( builder : NodeBuilder ) (abstract)
+
+This method is intended for implementing the ambient occlusion term. Unlike other methods, this method must be called manually by the lighting model in its indirect term.
+
+**builder**
+
+The current node builder.
+
+### .direct( lightData : Object, builder : NodeBuilder ) (abstract)
+
+This method is intended for implementing the direct light term and executed during the build process of directional, point and spot light nodes.
+
+**lightData**
+
+The light data.
+
+**builder**
+
+The current node builder.
+
+### .directRectArea( lightData : Object, builder : NodeBuilder ) (abstract)
+
+This method is intended for implementing the direct light term for rect area light nodes.
+
+**lightData**
+
+The light data.
+
+**builder**
+
+The current node builder.
+
+### .finish( builder : NodeBuilder ) (abstract)
+
+This method is intended for executing final tasks like final updates to the outgoing light.
+
+**builder**
+
+The current node builder.
+
+### .indirect( builder : NodeBuilder ) (abstract)
+
+This method is intended for implementing the indirect light term.
+
+**builder**
+
+The current node builder.
+
+### .start( builder : NodeBuilder ) (abstract)
+
+This method is intended for setting up lighting model and context data which are later used in the evaluation process.
+
+**builder**
+
+The current node builder.
+
+## Source
+
+[src/nodes/core/LightingModel.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/core/LightingModel.js)
\ No newline at end of file
diff --git a/docs/pages/LightingNode.html.md b/docs/pages/LightingNode.html.md
new file mode 100644
index 00000000000000..d58ab93db989b1
--- /dev/null
+++ b/docs/pages/LightingNode.html.md
@@ -0,0 +1,23 @@
+*Inheritance: EventDispatcher → Node →*
+
+# LightingNode
+
+Base class for lighting nodes.
+
+## Constructor
+
+### new LightingNode()
+
+Constructs a new lighting node.
+
+## Properties
+
+### .isLightingNode : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/nodes/lighting/LightingNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/lighting/LightingNode.js)
\ No newline at end of file
diff --git a/docs/pages/LightsNode.html.md b/docs/pages/LightsNode.html.md
new file mode 100644
index 00000000000000..2f190fceec0932
--- /dev/null
+++ b/docs/pages/LightsNode.html.md
@@ -0,0 +1,127 @@
+*Inheritance: EventDispatcher → Node →*
+
+# LightsNode
+
+This node represents the scene's lighting and manages the lighting model's life cycle for the current build 3D object. It is responsible for computing the total outgoing light in a given lighting context.
+
+## Constructor
+
+### new LightsNode()
+
+Constructs a new lights node.
+
+## Properties
+
+### .global : boolean
+
+`LightsNode` sets this property to `true` by default.
+
+Default is `true`.
+
+**Overrides:** [Node#global](Node.html#global)
+
+### .hasLights : boolean
+
+Whether the scene has lights or not.
+
+### .outgoingLightNode : Node.
+
+A node representing the outgoing light.
+
+### .totalDiffuseNode : Node.
+
+A node representing the total diffuse light.
+
+### .totalSpecularNode : Node.
+
+A node representing the total specular light.
+
+## Methods
+
+### .customCacheKey() : number
+
+Overwrites the default [Node#customCacheKey](Node.html#customCacheKey) implementation by including light data into the cache key.
+
+**Overrides:** [Node#customCacheKey](Node.html#customCacheKey)
+
+**Returns:** The custom cache key.
+
+### .getHash( builder : NodeBuilder ) : string
+
+Computes a hash value for identifying the current light nodes setup.
+
+**builder**
+
+A reference to the current node builder.
+
+**Overrides:** [Node#getHash](Node.html#getHash)
+
+**Returns:** The computed hash.
+
+### .getLights() : Array.
+
+Returns an array of the scene's lights.
+
+**Returns:** The scene's lights.
+
+### .setLights( lights : Array. ) : LightsNode
+
+Configures this node with an array of lights.
+
+**lights**
+
+An array of lights.
+
+**Returns:** A reference to this node.
+
+### .setup( builder : NodeBuilder ) : Node.
+
+The implementation makes sure that for each light in the scene there is a corresponding light node. By building the light nodes and evaluating the lighting model the outgoing light is computed.
+
+**builder**
+
+A reference to the current node builder.
+
+**Overrides:** [Node#setup](Node.html#setup)
+
+**Returns:** A node representing the outgoing light.
+
+### .setupDirectLight( builder : Object, lightNode : Object, lightData : Object )
+
+Sets up a direct light in the lighting model.
+
+**builder**
+
+The builder object containing the context and stack.
+
+**lightNode**
+
+The light node.
+
+**lightData**
+
+The light object containing color and direction properties.
+
+### .setupLights( builder : NodeBuilder, lightNodes : Array. )
+
+Setups the internal lights by building all respective light nodes.
+
+**builder**
+
+A reference to the current node builder.
+
+**lightNodes**
+
+An array of lighting nodes.
+
+### .setupLightsNode( builder : NodeBuilder )
+
+Creates lighting nodes for each scene light. This makes it possible to further process lights in the node system.
+
+**builder**
+
+A reference to the current node builder.
+
+## Source
+
+[src/nodes/lighting/LightsNode.js](https://github.com/mrdoob/three.js/blob/master/src/nodes/lighting/LightsNode.js)
\ No newline at end of file
diff --git a/docs/pages/Line.html.md b/docs/pages/Line.html.md
new file mode 100644
index 00000000000000..f6cf708b04eba9
--- /dev/null
+++ b/docs/pages/Line.html.md
@@ -0,0 +1,92 @@
+*Inheritance: EventDispatcher → Object3D →*
+
+# Line
+
+A continuous line. The line are rendered by connecting consecutive vertices with straight lines.
+
+## Code Example
+
+```js
+const material = new THREE.LineBasicMaterial( { color: 0x0000ff } );
+const points = [];
+points.push( new THREE.Vector3( - 10, 0, 0 ) );
+points.push( new THREE.Vector3( 0, 10, 0 ) );
+points.push( new THREE.Vector3( 10, 0, 0 ) );
+const geometry = new THREE.BufferGeometry().setFromPoints( points );
+const line = new THREE.Line( geometry, material );
+scene.add( line );
+```
+
+## Constructor
+
+### new Line( geometry : BufferGeometry, material : Material | Array. )
+
+Constructs a new line.
+
+**geometry**
+
+The line geometry.
+
+**material**
+
+The line material.
+
+## Properties
+
+### .geometry : BufferGeometry
+
+The line geometry.
+
+### .isLine : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .material : Material | Array.
+
+The line material.
+
+Default is `LineBasicMaterial`.
+
+### .morphTargetDictionary : Object. | undefined
+
+A dictionary representing the morph targets in the geometry. The key is the morph targets name, the value its attribute index. This member is `undefined` by default and only set when morph targets are detected in the geometry.
+
+Default is `undefined`.
+
+### .morphTargetInfluences : Array. | undefined
+
+An array of weights typically in the range `[0,1]` that specify how much of the morph is applied. This member is `undefined` by default and only set when morph targets are detected in the geometry.
+
+Default is `undefined`.
+
+## Methods
+
+### .computeLineDistances() : Line
+
+Computes an array of distance values which are necessary for rendering dashed lines. For each vertex in the geometry, the method calculates the cumulative length from the current point to the very beginning of the line.
+
+**Returns:** A reference to this line.
+
+### .raycast( raycaster : Raycaster, intersects : Array. )
+
+Computes intersection points between a casted ray and this line.
+
+**raycaster**
+
+The raycaster.
+
+**intersects**
+
+The target array that holds the intersection points.
+
+**Overrides:** [Object3D#raycast](Object3D.html#raycast)
+
+### .updateMorphTargets()
+
+Sets the values of [Line#morphTargetDictionary](Line.html#morphTargetDictionary) and [Line#morphTargetInfluences](Line.html#morphTargetInfluences) to make sure existing morph targets can influence this 3D object.
+
+## Source
+
+[src/objects/Line.js](https://github.com/mrdoob/three.js/blob/master/src/objects/Line.js)
\ No newline at end of file
diff --git a/docs/pages/Line2.html.md b/docs/pages/Line2.html.md
new file mode 100644
index 00000000000000..eee2f3c4b7d366
--- /dev/null
+++ b/docs/pages/Line2.html.md
@@ -0,0 +1,54 @@
+*Inheritance: EventDispatcher → Object3D → Mesh → LineSegments2 →*
+
+# Line2
+
+A polyline drawn between vertices.
+
+This adds functionality beyond [Line](Line.html), like arbitrary line width and changing width to be in world units.It extends [LineSegments2](LineSegments2.html), simplifying constructing segments from a chain of points.
+
+This module can only be used with [WebGLRenderer](WebGLRenderer.html). When using [WebGPURenderer](WebGPURenderer.html), import the class from `lines/webgpu/Line2.js`.
+
+## Code Example
+
+```js
+const geometry = new LineGeometry();
+geometry.setPositions( positions );
+geometry.setColors( colors );
+const material = new LineMaterial( { linewidth: 5, vertexColors: true } };
+const line = new Line2( geometry, material );
+scene.add( line );
+```
+
+## Import
+
+Line2 is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { Line2 } from 'three/addons/lines/Line2.js';
+```
+
+## Constructor
+
+### new Line2( geometry : LineGeometry, material : LineMaterial )
+
+Constructs a new wide line.
+
+**geometry**
+
+The line geometry.
+
+**material**
+
+The line material.
+
+## Properties
+
+### .isLine2 : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[examples/jsm/lines/Line2.js](https://github.com/mrdoob/three.js/blob/master/examples/jsm/lines/Line2.js)
\ No newline at end of file
diff --git a/docs/pages/Line2NodeMaterial.html.md b/docs/pages/Line2NodeMaterial.html.md
new file mode 100644
index 00000000000000..7e4691f3d6aa34
--- /dev/null
+++ b/docs/pages/Line2NodeMaterial.html.md
@@ -0,0 +1,111 @@
+*Inheritance: EventDispatcher → Material → NodeMaterial →*
+
+# Line2NodeMaterial
+
+This node material can be used to render lines with a size larger than one by representing them as instanced meshes.
+
+## Constructor
+
+### new Line2NodeMaterial( parameters : Object )
+
+Constructs a new node material for wide line rendering.
+
+**parameters**
+
+The configuration parameter.
+
+Default is `{}`.
+
+## Properties
+
+### .alphaToCoverage : boolean
+
+Whether alpha to coverage should be used or not.
+
+Default is `true`.
+
+**Overrides:** [NodeMaterial#alphaToCoverage](NodeMaterial.html#alphaToCoverage)
+
+### .blending : number
+
+Blending is set to `NoBlending` since transparency is not supported, yet.
+
+Default is `0`.
+
+**Overrides:** [NodeMaterial#blending](NodeMaterial.html#blending)
+
+### .dashOffset : number
+
+The dash offset.
+
+Default is `0`.
+
+### .dashScaleNode : Node.
+
+Defines the dash scale.
+
+Default is `null`.
+
+### .dashSizeNode : Node.
+
+Defines the dash size.
+
+Default is `null`.
+
+### .dashed : boolean
+
+Whether the lines should be dashed or not.
+
+Default is `false`.
+
+### .gapSizeNode : Node.
+
+Defines the gap size.
+
+Default is `null`.
+
+### .isLine2NodeMaterial : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .lineColorNode : Node.
+
+Defines the lines color.
+
+Default is `null`.
+
+### .offsetNode : Node.
+
+Defines the offset.
+
+Default is `null`.
+
+### .useColor : boolean
+
+Whether vertex colors should be used or not.
+
+Default is `false`.
+
+### .worldUnits : boolean
+
+Whether the lines should sized in world units or not. When set to `false` the unit is pixel.
+
+Default is `false`.
+
+## Methods
+
+### .setup( builder : NodeBuilder )
+
+Setups the vertex and fragment stage of this node material.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [NodeMaterial#setup](NodeMaterial.html#setup)
+
+## Source
+
+[src/materials/nodes/Line2NodeMaterial.js](https://github.com/mrdoob/three.js/blob/master/src/materials/nodes/Line2NodeMaterial.js)
\ No newline at end of file
diff --git a/docs/pages/Line3.html.md b/docs/pages/Line3.html.md
new file mode 100644
index 00000000000000..f96ada828b9595
--- /dev/null
+++ b/docs/pages/Line3.html.md
@@ -0,0 +1,183 @@
+# Line3
+
+An analytical line segment in 3D space represented by a start and end point.
+
+## Constructor
+
+### new Line3( start : Vector3, end : Vector3 )
+
+Constructs a new line segment.
+
+**start**
+
+Start of the line segment.
+
+Default is `(0,0,0)`.
+
+**end**
+
+End of the line segment.
+
+Default is `(0,0,0)`.
+
+## Properties
+
+### .end : Vector3
+
+End of the line segment.
+
+### .start : Vector3
+
+Start of the line segment.
+
+## Methods
+
+### .applyMatrix4( matrix : Matrix4 ) : Line3
+
+Applies a 4x4 transformation matrix to this line segment.
+
+**matrix**
+
+The transformation matrix.
+
+**Returns:** A reference to this line segment.
+
+### .at( t : number, target : Vector3 ) : Vector3
+
+Returns a vector at a certain position along the line segment.
+
+**t**
+
+A value between `[0,1]` to represent a position along the line segment.
+
+**target**
+
+The target vector that is used to store the method's result.
+
+**Returns:** The delta vector.
+
+### .clone() : Line3
+
+Returns a new line segment with copied values from this instance.
+
+**Returns:** A clone of this instance.
+
+### .closestPointToPoint( point : Vector3, clampToLine : boolean, target : Vector3 ) : Vector3
+
+Returns the closest point on the line for a given point.
+
+**point**
+
+The point to compute the closest point on the line for.
+
+**clampToLine**
+
+Whether to clamp the result to the range `[0,1]` or not.
+
+**target**
+
+The target vector that is used to store the method's result.
+
+**Returns:** The closest point on the line.
+
+### .closestPointToPointParameter( point : Vector3, clampToLine : boolean ) : number
+
+Returns a point parameter based on the closest point as projected on the line segment.
+
+**point**
+
+The point for which to return a point parameter.
+
+**clampToLine**
+
+Whether to clamp the result to the range `[0,1]` or not.
+
+**Returns:** The point parameter.
+
+### .copy( line : Line3 ) : Line3
+
+Copies the values of the given line segment to this instance.
+
+**line**
+
+The line segment to copy.
+
+**Returns:** A reference to this line segment.
+
+### .delta( target : Vector3 ) : Vector3
+
+Returns the delta vector of the line segment's start and end point.
+
+**target**
+
+The target vector that is used to store the method's result.
+
+**Returns:** The delta vector.
+
+### .distance() : number
+
+Returns the Euclidean distance between the line' start and end point.
+
+**Returns:** The Euclidean distance.
+
+### .distanceSq() : number
+
+Returns the squared Euclidean distance between the line' start and end point.
+
+**Returns:** The squared Euclidean distance.
+
+### .distanceSqToLine3( line : Line3, c1 : Vector3, c2 : Vector3 ) : number
+
+Returns the closest squared distance between this line segment and the given one.
+
+**line**
+
+The line segment to compute the closest squared distance to.
+
+**c1**
+
+The closest point on this line segment.
+
+**c2**
+
+The closest point on the given line segment.
+
+**Returns:** The squared distance between this line segment and the given one.
+
+### .equals( line : Line3 ) : boolean
+
+Returns `true` if this line segment is equal with the given one.
+
+**line**
+
+The line segment to test for equality.
+
+**Returns:** Whether this line segment is equal with the given one.
+
+### .getCenter( target : Vector3 ) : Vector3
+
+Returns the center of the line segment.
+
+**target**
+
+The target vector that is used to store the method's result.
+
+**Returns:** The center point.
+
+### .set( start : Vector3, end : Vector3 ) : Line3
+
+Sets the start and end values by copying the given vectors.
+
+**start**
+
+The start point.
+
+**end**
+
+The end point.
+
+**Returns:** A reference to this line segment.
+
+## Source
+
+[src/math/Line3.js](https://github.com/mrdoob/three.js/blob/master/src/math/Line3.js)
\ No newline at end of file
diff --git a/docs/pages/LineBasicMaterial.html.md b/docs/pages/LineBasicMaterial.html.md
new file mode 100644
index 00000000000000..f00e2afae9942a
--- /dev/null
+++ b/docs/pages/LineBasicMaterial.html.md
@@ -0,0 +1,77 @@
+*Inheritance: EventDispatcher → Material →*
+
+# LineBasicMaterial
+
+A material for rendering line primitives.
+
+Materials define the appearance of renderable 3D objects.
+
+## Code Example
+
+```js
+const material = new THREE.LineBasicMaterial( { color: 0xffffff } );
+```
+
+## Constructor
+
+### new LineBasicMaterial( parameters : Object )
+
+Constructs a new line basic material.
+
+**parameters**
+
+An object with one or more properties defining the material's appearance. Any property of the material (including any property from inherited materials) can be passed in here. Color values can be passed any type of value accepted by [Color#set](Color.html#set).
+
+## Properties
+
+### .color : Color
+
+Color of the material.
+
+Default is `(1,1,1)`.
+
+### .fog : boolean
+
+Whether the material is affected by fog or not.
+
+Default is `true`.
+
+### .isLineBasicMaterial : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .linecap : 'butt' | 'round' | 'square'
+
+Defines appearance of line ends.
+
+Can only be used with [SVGRenderer](SVGRenderer.html).
+
+Default is `'round'`.
+
+### .linejoin : 'round' | 'bevel' | 'miter'
+
+Defines appearance of line joints.
+
+Can only be used with [SVGRenderer](SVGRenderer.html).
+
+Default is `'round'`.
+
+### .linewidth : number
+
+Controls line thickness or lines.
+
+Can only be used with [SVGRenderer](SVGRenderer.html). WebGL and WebGPU ignore this setting and always render line primitives with a width of one pixel.
+
+Default is `1`.
+
+### .map : Texture
+
+Sets the color of the lines using data from a texture. The texture map color is modulated by the diffuse `color`.
+
+Default is `null`.
+
+## Source
+
+[src/materials/LineBasicMaterial.js](https://github.com/mrdoob/three.js/blob/master/src/materials/LineBasicMaterial.js)
\ No newline at end of file
diff --git a/docs/pages/LineBasicNodeMaterial.html.md b/docs/pages/LineBasicNodeMaterial.html.md
new file mode 100644
index 00000000000000..7fb05104119ece
--- /dev/null
+++ b/docs/pages/LineBasicNodeMaterial.html.md
@@ -0,0 +1,27 @@
+*Inheritance: EventDispatcher → Material → NodeMaterial →*
+
+# LineBasicNodeMaterial
+
+Node material version of [LineBasicMaterial](LineBasicMaterial.html).
+
+## Constructor
+
+### new LineBasicNodeMaterial( parameters : Object )
+
+Constructs a new line basic node material.
+
+**parameters**
+
+The configuration parameter.
+
+## Properties
+
+### .isLineBasicNodeMaterial : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Source
+
+[src/materials/nodes/LineBasicNodeMaterial.js](https://github.com/mrdoob/three.js/blob/master/src/materials/nodes/LineBasicNodeMaterial.js)
\ No newline at end of file
diff --git a/docs/pages/LineCurve.html.md b/docs/pages/LineCurve.html.md
new file mode 100644
index 00000000000000..33d65385fcfdf7
--- /dev/null
+++ b/docs/pages/LineCurve.html.md
@@ -0,0 +1,57 @@
+*Inheritance: Curve →*
+
+# LineCurve
+
+A curve representing a 2D line segment.
+
+## Constructor
+
+### new LineCurve( v1 : Vector2, v2 : Vector2 )
+
+Constructs a new line curve.
+
+**v1**
+
+The start point.
+
+**v2**
+
+The end point.
+
+## Properties
+
+### .isLineCurve : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .v1 : Vector2
+
+The start point.
+
+### .v2 : Vector2
+
+The end point.
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector2 ) : Vector2
+
+Returns a point on the line.
+
+**t**
+
+A interpolation factor representing a position on the line. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the line.
+
+## Source
+
+[src/extras/curves/LineCurve.js](https://github.com/mrdoob/three.js/blob/master/src/extras/curves/LineCurve.js)
\ No newline at end of file
diff --git a/docs/pages/LineCurve3.html.md b/docs/pages/LineCurve3.html.md
new file mode 100644
index 00000000000000..823c2c8d722fbf
--- /dev/null
+++ b/docs/pages/LineCurve3.html.md
@@ -0,0 +1,57 @@
+*Inheritance: Curve →*
+
+# LineCurve3
+
+A curve representing a 3D line segment.
+
+## Constructor
+
+### new LineCurve3( v1 : Vector3, v2 : Vector3 )
+
+Constructs a new line curve.
+
+**v1**
+
+The start point.
+
+**v2**
+
+The end point.
+
+## Properties
+
+### .isLineCurve3 : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .v1 : Vector3
+
+The start point.
+
+### .v2 : Vector2
+
+The end point.
+
+## Methods
+
+### .getPoint( t : number, optionalTarget : Vector3 ) : Vector3
+
+Returns a point on the line.
+
+**t**
+
+A interpolation factor representing a position on the line. Must be in the range `[0,1]`.
+
+**optionalTarget**
+
+The optional target vector the result is written to.
+
+**Overrides:** [Curve#getPoint](Curve.html#getPoint)
+
+**Returns:** The position on the line.
+
+## Source
+
+[src/extras/curves/LineCurve3.js](https://github.com/mrdoob/three.js/blob/master/src/extras/curves/LineCurve3.js)
\ No newline at end of file
diff --git a/docs/pages/LineDashedMaterial.html.md b/docs/pages/LineDashedMaterial.html.md
new file mode 100644
index 00000000000000..8ad70084069ecd
--- /dev/null
+++ b/docs/pages/LineDashedMaterial.html.md
@@ -0,0 +1,58 @@
+*Inheritance: EventDispatcher → Material → LineBasicMaterial →*
+
+# LineDashedMaterial
+
+A material for rendering line primitives.
+
+Materials define the appearance of renderable 3D objects.
+
+## Code Example
+
+```js
+const material = new THREE.LineDashedMaterial( {
+ color: 0xffffff,
+ scale: 1,
+ dashSize: 3,
+ gapSize: 1,
+} );
+```
+
+## Constructor
+
+### new LineDashedMaterial( parameters : Object )
+
+Constructs a new line dashed material.
+
+**parameters**
+
+An object with one or more properties defining the material's appearance. Any property of the material (including any property from inherited materials) can be passed in here. Color values can be passed any type of value accepted by [Color#set](Color.html#set).
+
+## Properties
+
+### .dashSize : number
+
+The size of the dash. This is both the gap with the stroke.
+
+Default is `3`.
+
+### .gapSize : number
+
+The size of the gap.
+
+Default is `1`.
+
+### .isLineDashedMaterial : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .scale : number
+
+The scale of the dashed part of a line.
+
+Default is `1`.
+
+## Source
+
+[src/materials/LineDashedMaterial.js](https://github.com/mrdoob/three.js/blob/master/src/materials/LineDashedMaterial.js)
\ No newline at end of file
diff --git a/docs/pages/LineDashedNodeMaterial.html.md b/docs/pages/LineDashedNodeMaterial.html.md
new file mode 100644
index 00000000000000..7e2f1e51f6e193
--- /dev/null
+++ b/docs/pages/LineDashedNodeMaterial.html.md
@@ -0,0 +1,77 @@
+*Inheritance: EventDispatcher → Material → NodeMaterial →*
+
+# LineDashedNodeMaterial
+
+Node material version of [LineDashedMaterial](LineDashedMaterial.html).
+
+## Constructor
+
+### new LineDashedNodeMaterial( parameters : Object )
+
+Constructs a new line dashed node material.
+
+**parameters**
+
+The configuration parameter.
+
+## Properties
+
+### .dashOffset : number
+
+The dash offset.
+
+Default is `0`.
+
+### .dashScaleNode : Node.
+
+The scale of dash materials is by default inferred from the `scale` property. This node property allows to overwrite the default and define the scale with a node instead.
+
+If you don't want to overwrite the scale but modify the existing value instead, use [materialLineScale](TSL.html#materialLineScale).
+
+Default is `null`.
+
+### .dashSizeNode : Node.
+
+The dash size of dash materials is by default inferred from the `dashSize` property. This node property allows to overwrite the default and define the dash size with a node instead.
+
+If you don't want to overwrite the dash size but modify the existing value instead, use [materialLineDashSize](TSL.html#materialLineDashSize).
+
+Default is `null`.
+
+### .gapSizeNode : Node.
+
+The gap size of dash materials is by default inferred from the `gapSize` property. This node property allows to overwrite the default and define the gap size with a node instead.
+
+If you don't want to overwrite the gap size but modify the existing value instead, use [materialLineGapSize](TSL.html#materialLineGapSize).
+
+Default is `null`.
+
+### .isLineDashedNodeMaterial : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+### .offsetNode : Node.
+
+The offset of dash materials is by default inferred from the `dashOffset` property. This node property allows to overwrite the default and define the offset with a node instead.
+
+If you don't want to overwrite the offset but modify the existing value instead, use [materialLineDashOffset](TSL.html#materialLineDashOffset).
+
+Default is `null`.
+
+## Methods
+
+### .setupVariants( builder : NodeBuilder )
+
+Setups the dash specific node variables.
+
+**builder**
+
+The current node builder.
+
+**Overrides:** [NodeMaterial#setupVariants](NodeMaterial.html#setupVariants)
+
+## Source
+
+[src/materials/nodes/LineDashedNodeMaterial.js](https://github.com/mrdoob/three.js/blob/master/src/materials/nodes/LineDashedNodeMaterial.js)
\ No newline at end of file
diff --git a/docs/pages/LineGeometry.html.md b/docs/pages/LineGeometry.html.md
new file mode 100644
index 00000000000000..9fa795116a2206
--- /dev/null
+++ b/docs/pages/LineGeometry.html.md
@@ -0,0 +1,91 @@
+*Inheritance: InstancedBufferGeometry → LineSegmentsGeometry →*
+
+# LineGeometry
+
+A chain of vertices, forming a polyline.
+
+This is used in [Line2](Line2.html) to describe the shape.
+
+## Code Example
+
+```js
+const points = [
+ new THREE.Vector3( - 10, 0, 0 ),
+ new THREE.Vector3( 0, 5, 0 ),
+ new THREE.Vector3( 10, 0, 0 ),
+];
+const geometry = new LineGeometry();
+geometry.setFromPoints( points );
+```
+
+## Import
+
+LineGeometry is an addon, and must be imported explicitly, see [Installation#Addons](https://threejs.org/manual/#en/installation).
+
+```js
+import { LineLineGeometry2 } from 'three/addons/lines/LineGeometry.js';
+```
+
+## Constructor
+
+### new LineGeometry()
+
+Constructs a new line geometry.
+
+## Properties
+
+### .isLineGeometry : boolean (readonly)
+
+This flag can be used for type testing.
+
+Default is `true`.
+
+## Methods
+
+### .fromLine( line : Line ) : LineGeometry
+
+Setups this line segments geometry from the given line.
+
+**line**
+
+The line that should be used as a data source for this geometry.
+
+**Returns:** A reference to this geometry.
+
+### .setColors( array : Float32Array | Array. ) : LineGeometry
+
+Sets the given line colors for this geometry.
+
+**array**
+
+The position data to set.
+
+**Overrides:** [LineSegmentsGeometry#setColors](LineSegmentsGeometry.html#setColors)
+
+**Returns:** A reference to this geometry.
+
+### .setFromPoints( points : Array.<(Vector3|Vector2)> ) : LineGeometry
+
+Setups this line segments geometry from the given sequence of points.
+
+**points**
+
+An array of points in 2D or 3D space.
+
+**Returns:** A reference to this geometry.
+
+### .setPositions( array : Float32Array | Array.