@luma.gl/engine 9.0.0-beta.8 → 9.0.0-beta.9

package/dist/dist.dev.js

@@ -273,8 +273,6 @@ var __exports__ = (() => {
   // ../../node_modules/@probe.gl/stats/dist/lib/stat.js
   var Stat = class {
     constructor(name, type) {
-      this.name = void 0;
-      this.type = void 0;
       this.sampleSize = 1;
       this.time = 0;
       this.count = 0;
@@ -309,26 +307,31 @@ var __exports__ = (() => {
       this.sampleSize = samples;
       return this;
     }
+    /** Call to increment count (+1) */
     incrementCount() {
       this.addCount(1);
       return this;
     }
+    /** Call to decrement count (-1) */
     decrementCount() {
       this.subtractCount(1);
       return this;
     }
+    /** Increase count */
     addCount(value) {
       this._count += value;
       this._samples++;
       this._checkSampling();
       return this;
     }
+    /** Decrease count */
     subtractCount(value) {
       this._count -= value;
       this._samples++;
       this._checkSampling();
       return this;
     }
+    /** Add an arbitrary timing and bump the count */
     addTime(time) {
       this._time += time;
       this.lastTiming = time;
@@ -336,11 +339,13 @@ var __exports__ = (() => {
       this._checkSampling();
       return this;
     }
+    /** Start a timer */
     timeStart() {
       this._startTime = getHiResTimestamp();
       this._timerPending = true;
       return this;
     }
+    /** End a timer. Adds to time and bumps the timing count. */
     timeEnd() {
       if (!this._timerPending) {
         return this;
@@ -353,18 +358,22 @@ var __exports__ = (() => {
     getSampleAverageCount() {
       return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
     }
+    /** Calculate average time / count for the previous window */
     getSampleAverageTime() {
       return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
     }
+    /** Calculate counts per second for the previous window */
     getSampleHz() {
       return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
     }
     getAverageCount() {
       return this.samples > 0 ? this.count / this.samples : 0;
     }
+    /** Calculate average time / count */
     getAverageTime() {
       return this.samples > 0 ? this.time / this.samples : 0;
     }
+    /** Calculate counts per second */
     getHz() {
       return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
     }
@@ -385,23 +394,20 @@ var __exports__ = (() => {
   // ../../node_modules/@probe.gl/stats/dist/lib/stats.js
   var Stats = class {
     constructor(options) {
-      this.id = void 0;
       this.stats = {};
       this.id = options.id;
       this.stats = {};
       this._initializeStats(options.stats);
       Object.seal(this);
     }
-    get(name) {
-      let type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "count";
-      return this._getOrCreate({
-        name,
-        type
-      });
+    /** Acquire a stat. Create if it doesn't exist. */
+    get(name, type = "count") {
+      return this._getOrCreate({ name, type });
     }
     get size() {
       return Object.keys(this.stats).length;
     }
+    /** Reset all stats */
     reset() {
       for (const stat of Object.values(this.stats)) {
         stat.reset();
@@ -425,15 +431,11 @@ var __exports__ = (() => {
       });
       return table;
     }
-    _initializeStats() {
-      let stats = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    _initializeStats(stats = []) {
       stats.forEach((stat) => this._getOrCreate(stat));
     }
     _getOrCreate(stat) {
-      const {
-        name,
-        type
-      } = stat;
+      const { name, type } = stat;
       let result = this.stats[name];
       if (!result) {
         if (stat instanceof Stat) {
@@ -1285,62 +1287,6 @@ ${moduleSource}
 `;
     }
   }
-  function getVersionDefines(platformInfo) {
-    let versionDefines = "";
-    if (platformInfo.features.has("webgl2")) {
-      versionDefines += glsl`\
-# define FEATURE_GLSL_DERIVATIVES
-# define FEATURE_GLSL_DRAW_BUFFERS
-# define FEATURE_GLSL_FRAG_DEPTH
-# define FEATURE_GLSL_TEXTURE_LOD
-`;
-    }
-    if (!platformInfo.features.has("webgl2")) {
-      if (platformInfo.features.has("glsl-frag-depth")) {
-        versionDefines += glsl`\
-
-// FEATURE_GLSL_FRAG_DEPTH => gl_FragDepth is available
-#ifdef GL_EXT_frag_depth
-# extension GL_EXT_frag_depth : enable
-# define FEATURE_GLSL_FRAG_DEPTH
-# define FRAG_DEPTH
-# define gl_FragDepth gl_FragDepthEXT
-#endif
-`;
-      }
-      if (platformInfo?.features.has("glsl-derivatives")) {
-        versionDefines += glsl`\
-
-// FEATURE_GLSL_DERIVATIVES => dxdF, dxdY and fwidth are available
-#if defined(GL_OES_standard_derivatives) || defined(FEATURE_GLSL_DERIVATIVES)
-# extension GL_OES_standard_derivatives : enable
-# define FEATURE_GLSL_DERIVATIVES
-#endif
-`;
-      }
-      if (platformInfo?.features.has("glsl-frag-data")) {
-        versionDefines += glsl`\
-
-// FEATURE_GLSL_DRAW_BUFFERS => gl_FragData[] is available
-#ifdef GL_EXT_draw_buffers
-# extension GL_EXT_draw_buffers : require
-# define FEATURE_GLSL_DRAW_BUFFERS
-#endif
-`;
-      }
-      if (platformInfo?.features.has("glsl-texture-lod")) {
-        versionDefines += glsl`\
-// TEXTURE_LOD => texture2DLod etc are available
-#ifdef GL_EXT_shader_texture_lod
-# extension GL_EXT_shader_texture_lod : enable
-# define FEATURE_GLSL_TEXTURE_LOD
-# define TEXTURE_LOD
-#endif
-`;
-      }
-    }
-    return versionDefines;
-  }
 
   // ../shadertools/src/lib/shader-transpiler/transpile-glsl-shader.ts
   function transpileGLSLShader(source, stage) {
@@ -1628,7 +1574,6 @@ precision highp float;
 ${getShaderNameDefine({ id, source, stage })}
 ${`#define SHADER_TYPE_${stage.toUpperCase()}`}
 ${getPlatformShaderDefines(platformInfo)}
-${getVersionDefines(platformInfo)}
 ${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""}
 
 // ----- APPLICATION DEFINES -------------------------
@@ -4778,17 +4723,11 @@ void main() {
     printRowMajor: true,
     _cartographicRadians: false
   };
-  globalThis.mathgl = globalThis.mathgl || {
-    config: {
-      ...DEFAULT_CONFIG
-    }
-  };
+  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
   var config = globalThis.mathgl.config;
-  function formatValue(value, {
-    precision = config.precision
-  } = {}) {
+  function formatValue(value, { precision = config.precision } = {}) {
     value = round(value);
-    return "".concat(parseFloat(value.toPrecision(precision)));
+    return `${parseFloat(value.toPrecision(precision))}`;
   }
   function isArray(value) {
     return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
@@ -4832,28 +4771,12 @@ void main() {
   }
 
   // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
-  function _extendableBuiltin(cls) {
-    function ExtendableBuiltin() {
-      var instance = Reflect.construct(cls, Array.from(arguments));
-      Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
-      return instance;
-    }
-    ExtendableBuiltin.prototype = Object.create(cls.prototype, {
-      constructor: {
-        value: cls,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(ExtendableBuiltin, cls);
-    } else {
-      ExtendableBuiltin.__proto__ = cls;
-    }
-    return ExtendableBuiltin;
-  }
-  var MathArray = class extends _extendableBuiltin(Array) {
+  var MathArray = class extends Array {
+    // Common methods
+    /**
+     * Clone the current object
+     * @returns a new copy of this object
+     */
     clone() {
       return new this.constructor().copy(this);
     }
@@ -4873,7 +4796,10 @@ void main() {
       return targetObject;
     }
     from(arrayOrObject) {
-      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : (
+        // @ts-ignore
+        this.fromObject(arrayOrObject)
+      );
     }
     to(arrayOrObject) {
       if (arrayOrObject === this) {
@@ -4884,18 +4810,20 @@ void main() {
     toTarget(target) {
       return target ? this.to(target) : this;
     }
+    /** @deprecated */
     toFloat32Array() {
       return new Float32Array(this);
     }
     toString() {
       return this.formatString(config);
     }
+    /** Formats string according to options */
     formatString(opts) {
       let string = "";
       for (let i = 0; i < this.ELEMENTS; ++i) {
         string += (i > 0 ? ", " : "") + formatValue(this[i], opts);
       }
-      return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]");
+      return `${opts.printTypes ? this.constructor.name : ""}[${string}]`;
     }
     equals(array) {
       if (!array || this.length !== array.length) {
@@ -4919,6 +4847,8 @@ void main() {
       }
       return true;
     }
+    // Modifiers
+    /** Negates all values in this object */
     negate() {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = -this[i];
@@ -4936,12 +4866,14 @@ void main() {
       }
       return this.check();
     }
+    /** Minimal */
     min(vector) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.min(vector[i], this[i]);
       }
       return this.check();
     }
+    /** Maximal */
     max(vector) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.max(vector[i], this[i]);
@@ -4982,18 +4914,25 @@ void main() {
       }
       return this.check();
     }
+    /**
+     * Multiplies all elements by `scale`
+     * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
+     */
     multiplyByScalar(scalar) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] *= scalar;
       }
       return this.check();
     }
+    // Debug checks
+    /** Throws an error if array length is incorrect or contains illegal values */
     check() {
       if (config.debug && !this.validate()) {
-        throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
+        throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
       }
       return this;
     }
+    /** Returns false if the array length is incorrect or contains illegal values */
     validate() {
       let valid = this.length === this.ELEMENTS;
       for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -5001,39 +4940,48 @@ void main() {
       }
       return valid;
     }
+    // three.js compatibility
+    /** @deprecated */
     sub(a) {
       return this.subtract(a);
     }
+    /** @deprecated */
     setScalar(a) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = a;
       }
       return this.check();
     }
+    /** @deprecated */
     addScalar(a) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] += a;
       }
       return this.check();
     }
+    /** @deprecated */
     subScalar(a) {
       return this.addScalar(-a);
     }
+    /** @deprecated */
     multiplyScalar(scalar) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] *= scalar;
       }
       return this.check();
     }
+    /** @deprecated */
     divideScalar(a) {
       return this.multiplyByScalar(1 / a);
     }
+    /** @deprecated */
     clampScalar(min, max) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.min(Math.max(this[i], min), max);
       }
       return this.check();
     }
+    /** @deprecated */
     get elements() {
       return this;
     }
@@ -5053,13 +5001,13 @@ void main() {
   }
   function checkNumber(value) {
     if (!Number.isFinite(value)) {
-      throw new Error("Invalid number ".concat(JSON.stringify(value)));
+      throw new Error(`Invalid number ${JSON.stringify(value)}`);
     }
     return value;
   }
   function checkVector(v, length, callerName = "") {
     if (config.debug && !validateVector(v, length)) {
-      throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'"));
+      throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
     }
     return v;
   }
@@ -5067,12 +5015,13 @@ void main() {
   // ../../node_modules/@math.gl/core/dist/lib/assert.js
   function assert2(condition, message) {
     if (!condition) {
-      throw new Error("math.gl assertion ".concat(message));
+      throw new Error(`math.gl assertion ${message}`);
     }
   }
 
   // ../../node_modules/@math.gl/core/dist/classes/base/vector.js
   var Vector = class extends MathArray {
+    // ACCESSORS
     get x() {
       return this[0];
     }
@@ -5085,12 +5034,24 @@ void main() {
     set y(value) {
       this[1] = checkNumber(value);
     }
+    /**
+     * Returns the length of the vector from the origin to the point described by this vector
+     *
+     * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements
+     * Instead we provide `len` and `magnitude`
+     */
     len() {
       return Math.sqrt(this.lengthSquared());
     }
+    /**
+     * Returns the length of the vector from the origin to the point described by this vector
+     */
     magnitude() {
       return this.len();
     }
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
     lengthSquared() {
       let length = 0;
       for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -5098,6 +5059,9 @@ void main() {
       }
       return length;
     }
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
     magnitudeSquared() {
       return this.lengthSquared();
     }
@@ -5119,6 +5083,7 @@ void main() {
       }
       return checkNumber(product);
     }
+    // MODIFIERS
     normalize() {
       const length = this.magnitude();
       if (length !== 0) {
@@ -5144,6 +5109,7 @@ void main() {
       }
       return this.check();
     }
+    // THREE.js compatibility
     lengthSq() {
       return this.lengthSquared();
     }
@@ -5416,6 +5382,12 @@ void main() {
       }
       return ZERO;
     }
+    /**
+     * @class
+     * @param x
+     * @param y
+     * @param z
+     */
     constructor(x = 0, y = 0, z = 0) {
       super(-0, -0, -0);
       if (arguments.length === 1 && isArray(x)) {
@@ -5460,6 +5432,7 @@ void main() {
       object.z = this[2];
       return object;
     }
+    // Getters/setters
     get ELEMENTS() {
       return 3;
     }
@@ -5469,41 +5442,38 @@ void main() {
     set z(value) {
       this[2] = checkNumber(value);
     }
+    // ACCESSORS
     angle(vector) {
       return angle(this, vector);
     }
+    // MODIFIERS
     cross(vector) {
       cross(this, this, vector);
       return this.check();
     }
-    rotateX({
-      radians,
-      origin = ORIGIN
-    }) {
+    rotateX({ radians, origin = ORIGIN }) {
       rotateX(this, this, origin, radians);
       return this.check();
     }
-    rotateY({
-      radians,
-      origin = ORIGIN
-    }) {
+    rotateY({ radians, origin = ORIGIN }) {
       rotateY(this, this, origin, radians);
       return this.check();
     }
-    rotateZ({
-      radians,
-      origin = ORIGIN
-    }) {
+    rotateZ({ radians, origin = ORIGIN }) {
       rotateZ(this, this, origin, radians);
       return this.check();
     }
+    // Transforms
+    // transforms as point (4th component is implicitly 1)
     transform(matrix4) {
       return this.transformAsPoint(matrix4);
     }
+    // transforms as point (4th component is implicitly 1)
     transformAsPoint(matrix4) {
       transformMat42(this, this, matrix4);
       return this.check();
     }
+    // transforms as vector  (4th component is implicitly 0, ignores translation. slightly faster)
     transformAsVector(matrix4) {
       vec3_transformMat4AsVector(this, this, matrix4);
       return this.check();
@@ -5524,19 +5494,29 @@ void main() {
 
   // ../../node_modules/@math.gl/core/dist/classes/base/matrix.js
   var Matrix = class extends MathArray {
+    // fromObject(object) {
+    //   const array = object.elements;
+    //   return this.fromRowMajor(array);
+    // }
+    // toObject(object) {
+    //   const array = object.elements;
+    //   this.toRowMajor(array);
+    //   return object;
+    // }
+    // TODO better override formatString?
     toString() {
       let string = "[";
       if (config.printRowMajor) {
         string += "row-major:";
         for (let row = 0; row < this.RANK; ++row) {
           for (let col = 0; col < this.RANK; ++col) {
-            string += " ".concat(this[col * this.RANK + row]);
+            string += ` ${this[col * this.RANK + row]}`;
           }
         }
       } else {
         string += "column-major:";
         for (let i = 0; i < this.ELEMENTS; ++i) {
-          string += " ".concat(this[i]);
+          string += ` ${this[i]}`;
         }
       }
       string += "]";
@@ -5545,9 +5525,11 @@ void main() {
     getElementIndex(row, col) {
       return col * this.RANK + row;
     }
+    // By default assumes row major indices
     getElement(row, col) {
       return this[col * this.RANK + row];
     }
+    // By default assumes row major indices
     setElement(row, col, value) {
       this[col * this.RANK + row] = checkNumber(value);
       return this;
@@ -6313,6 +6295,7 @@ void main() {
       this[15] = array[15];
       return this.check();
     }
+    // eslint-disable-next-line max-params
     set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) {
       this[0] = m00;
       this[1] = m10;
@@ -6332,6 +6315,8 @@ void main() {
       this[15] = m33;
       return this.check();
     }
+    // accepts row major order, stores as column major
+    // eslint-disable-next-line max-params
     setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
       this[0] = m00;
       this[1] = m10;
@@ -6370,25 +6355,41 @@ void main() {
       result[15] = this[15];
       return result;
     }
+    // Constructors
+    /** Set to identity matrix */
     identity() {
       return this.copy(IDENTITY_MATRIX);
     }
+    /**
+     *
+     * @param object
+     * @returns self
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     fromObject(object) {
       return this.check();
     }
+    /**
+     * Calculates a 4x4 matrix from the given quaternion
+     * @param quaternion Quaternion to create matrix from
+     * @returns self
+     */
     fromQuaternion(quaternion) {
       fromQuat(this, quaternion);
       return this.check();
     }
+    /**
+     * Generates a frustum matrix with the given bounds
+     * @param view.left - Left bound of the frustum
+     * @param view.right - Right bound of the frustum
+     * @param view.bottom - Bottom bound of the frustum
+     * @param view.top - Top bound of the frustum
+     * @param view.near - Near bound of the frustum
+     * @param view.far - Far bound of the frustum. Can be set to Infinity.
+     * @returns self
+     */
     frustum(view) {
-      const {
-        left,
-        right,
-        bottom,
-        top,
-        near = DEFAULT_NEAR,
-        far = DEFAULT_FAR
-      } = view;
+      const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
       if (far === Infinity) {
         computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
       } else {
@@ -6396,35 +6397,47 @@ void main() {
       }
       return this.check();
     }
+    /**
+     * Generates a look-at matrix with the given eye position, focal point,
+     * and up axis
+     * @param view.eye - (vector) Position of the viewer
+     * @param view.center - (vector) Point the viewer is looking at
+     * @param view.up - (vector) Up axis
+     * @returns self
+     */
     lookAt(view) {
-      const {
-        eye,
-        center = [0, 0, 0],
-        up = [0, 1, 0]
-      } = view;
+      const { eye, center = [0, 0, 0], up = [0, 1, 0] } = view;
       lookAt(this, eye, center, up);
       return this.check();
     }
+    /**
+     * Generates a orthogonal projection matrix with the given bounds
+     * from "traditional" view space parameters
+     * @param view.left - Left bound of the frustum
+     * @param view.right number  Right bound of the frustum
+     * @param view.bottom - Bottom bound of the frustum
+     * @param view.top number  Top bound of the frustum
+     * @param view.near - Near bound of the frustum
+     * @param view.far number  Far bound of the frustum
+     * @returns self
+     */
     ortho(view) {
-      const {
-        left,
-        right,
-        bottom,
-        top,
-        near = DEFAULT_NEAR,
-        far = DEFAULT_FAR
-      } = view;
+      const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
       ortho(this, left, right, bottom, top, near, far);
       return this.check();
     }
+    /**
+     * Generates an orthogonal projection matrix with the same parameters
+     * as a perspective matrix (plus focalDistance)
+     * @param view.fovy Vertical field of view in radians
+     * @param view.aspect Aspect ratio. Typically viewport width / viewport height
+     * @param view.focalDistance Distance in the view frustum used for extent calculations
+     * @param view.near Near bound of the frustum
+     * @param view.far Far bound of the frustum
+     * @returns self
+     */
     orthographic(view) {
-      const {
-        fovy = DEFAULT_FOVY,
-        aspect = DEFAULT_ASPECT,
-        focalDistance = 1,
-        near = DEFAULT_NEAR,
-        far = DEFAULT_FAR
-      } = view;
+      const { fovy = DEFAULT_FOVY, aspect = DEFAULT_ASPECT, focalDistance = 1, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
       checkRadians(fovy);
       const halfY = fovy / 2;
       const top = focalDistance * Math.tan(halfY);
@@ -6438,32 +6451,53 @@ void main() {
         far
       });
     }
+    /**
+     * Generates a perspective projection matrix with the given bounds
+     * @param view.fovy Vertical field of view in radians
+     * @param view.aspect Aspect ratio. typically viewport width/height
+     * @param view.near Near bound of the frustum
+     * @param view.far Far bound of the frustum
+     * @returns self
+     */
     perspective(view) {
-      const {
-        fovy = 45 * Math.PI / 180,
-        aspect = 1,
-        near = 0.1,
-        far = 500
-      } = view;
+      const { fovy = 45 * Math.PI / 180, aspect = 1, near = 0.1, far = 500 } = view;
       checkRadians(fovy);
       perspective(this, fovy, aspect, near, far);
       return this.check();
     }
+    // Accessors
     determinant() {
       return determinant(this);
     }
+    /**
+     * Extracts the non-uniform scale assuming the matrix is an affine transformation.
+     * The scales are the "lengths" of the column vectors in the upper-left 3x3 matrix.
+     * @param result
+     * @returns self
+     */
     getScale(result = [-0, -0, -0]) {
       result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]);
       result[1] = Math.sqrt(this[4] * this[4] + this[5] * this[5] + this[6] * this[6]);
       result[2] = Math.sqrt(this[8] * this[8] + this[9] * this[9] + this[10] * this[10]);
       return result;
     }
+    /**
+     * Gets the translation portion, assuming the matrix is a affine transformation matrix.
+     * @param result
+     * @returns self
+     */
     getTranslation(result = [-0, -0, -0]) {
       result[0] = this[12];
       result[1] = this[13];
       result[2] = this[14];
       return result;
     }
+    /**
+     * Gets upper left 3x3 pure rotation matrix (non-scaling), assume affine transformation matrix
+     * @param result
+     * @param scaleResult
+     * @returns self
+     */
     getRotation(result, scaleResult) {
       result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
       scaleResult = scaleResult || [-0, -0, -0];
@@ -6489,6 +6523,12 @@ void main() {
       result[15] = 1;
       return result;
     }
+    /**
+     *
+     * @param result
+     * @param scaleResult
+     * @returns self
+     */
     getRotationMatrix3(result, scaleResult) {
       result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0];
       scaleResult = scaleResult || [-0, -0, -0];
@@ -6507,6 +6547,7 @@ void main() {
       result[8] = this[10] * inverseScale2;
       return result;
     }
+    // Modifiers
     transpose() {
       transpose(this, this);
       return this.check();
@@ -6515,6 +6556,7 @@ void main() {
       invert(this, this);
       return this.check();
     }
+    // Operations
     multiplyLeft(a) {
       multiply(this, a, this);
       return this.check();
@@ -6523,33 +6565,68 @@ void main() {
       multiply(this, this, a);
       return this.check();
     }
+    // Rotates a matrix by the given angle around the X axis
     rotateX(radians) {
       rotateX2(this, this, radians);
       return this.check();
     }
+    // Rotates a matrix by the given angle around the Y axis.
     rotateY(radians) {
       rotateY2(this, this, radians);
       return this.check();
     }
+    /**
+     * Rotates a matrix by the given angle around the Z axis.
+     * @param radians
+     * @returns self
+     */
     rotateZ(radians) {
       rotateZ2(this, this, radians);
       return this.check();
     }
+    /**
+     *
+     * @param param0
+     * @returns self
+     */
     rotateXYZ(angleXYZ) {
       return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]);
     }
+    /**
+     *
+     * @param radians
+     * @param axis
+     * @returns self
+     */
     rotateAxis(radians, axis) {
       rotate(this, this, radians, axis);
       return this.check();
     }
+    /**
+     *
+     * @param factor
+     * @returns self
+     */
     scale(factor) {
       scale(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
       return this.check();
     }
+    /**
+     *
+     * @param vec
+     * @returns self
+     */
     translate(vector) {
       translate(this, this, vector);
       return this.check();
     }
+    // Transforms
+    /**
+     * Transforms any 2, 3 or 4 element vector. 2 and 3 elements are treated as points
+     * @param vector
+     * @param result
+     * @returns self
+     */
     transform(vector, result) {
       if (vector.length === 4) {
         result = transformMat43(result || [-0, -0, -0, -0], vector, this);
@@ -6558,10 +6635,14 @@ void main() {
       }
       return this.transformAsPoint(vector, result);
     }
+    /**
+     * Transforms any 2 or 3 element array as point (w implicitly 1)
+     * @param vector
+     * @param result
+     * @returns self
+     */
     transformAsPoint(vector, result) {
-      const {
-        length
-      } = vector;
+      const { length } = vector;
       let out;
       switch (length) {
         case 2:
@@ -6576,6 +6657,12 @@ void main() {
       checkVector(out, vector.length);
       return out;
     }
+    /**
+     * Transforms any 2 or 3 element array as vector (w implicitly 0)
+     * @param vector
+     * @param result
+     * @returns self
+     */
     transformAsVector(vector, result) {
       let out;
       switch (vector.length) {
@@ -6591,15 +6678,19 @@ void main() {
       checkVector(out, vector.length);
       return out;
     }
+    /** @deprecated */
     transformPoint(vector, result) {
       return this.transformAsPoint(vector, result);
     }
+    /** @deprecated */
     transformVector(vector, result) {
       return this.transformAsPoint(vector, result);
     }
+    /** @deprecated */
     transformDirection(vector, result) {
       return this.transformAsVector(vector, result);
     }
+    // three.js math API compatibility
     makeRotationX(radians) {
       return this.identity().rotateX(radians);
     }