@lakuna/umath 1.3.4 → 1.3.6

package/dist/linalg/Quaternion.js

@@ -1,9 +1,21 @@
-import Vector4, { add, copy, dot, equals, exactEquals, fromValues, getMagnitude, getSquaredMagnitude, lerp, normalize, scale } from "#Vector4";
-import epsilon from "#epsilon";
-export function createQuaternionLike() {
+import { createMatrix3Like } from "./Matrix3.js";
+import { add, copy, dot, equals, exactEquals, fromValues, getMagnitude, getSquaredMagnitude, lerp, normalize, scale } from "./Vector4.js";
+import epsilon from "../utility/epsilon.js";
+/**
+ * Create a quaternion-like object.
+ * @returns A quaternion-like object.
+ */
+export const createQuaternionLike = () => {
     return new Float32Array(4);
-}
-export function fromMatrix3(matrix, out) {
+};
+/**
+ * Create a quaternion from a three-by-three rotation matrix.
+ * @param matrix - The matrix.
+ * @param out - The quaternion to store the result in.
+ * @returns The quaternion.
+ * @see [Rotation matrix](https://en.wikipedia.org/wiki/Rotation_matrix)
+ */
+export const fromMatrix3 = (matrix, out) => {
     const fTrace = matrix[0] + matrix[4] + matrix[8];
     if (fTrace > 0) {
         let fRoot = Math.sqrt(fTrace + 1);
@@ -18,26 +30,38 @@ export function fromMatrix3(matrix, out) {
     if (matrix[4] > matrix[0]) {
         i = 1;
     }
-    if (matrix[8] > matrix[i * 3 + i]) {
+    if (matrix[8] > matrix[(i * 3 + i)]) {
         i = 2;
     }
-    const j = (i + 1) % 3;
-    const k = (i + 2) % 3;
-    let fRoot = Math.sqrt(matrix[i * 3 + i] -
-        matrix[j * 3 + j] -
-        matrix[k * 3 + k] +
+    const j = ((i + 1) % 3);
+    const k = ((i + 2) % 3);
+    let fRoot = Math.sqrt(matrix[(i * 3 + i)] -
+        matrix[(j * 3 + j)] -
+        matrix[(k * 3 + k)] +
         1);
     out[i] = 0.5 * fRoot;
     fRoot = 0.5 / fRoot;
     out[3] =
-        (matrix[j * 3 + k] - matrix[k * 3 + j]) * fRoot;
+        (matrix[(j * 3 + k)] - matrix[(k * 3 + j)]) *
+            fRoot;
     out[j] =
-        (matrix[j * 3 + i] + matrix[i * 3 + j]) * fRoot;
+        (matrix[(j * 3 + i)] + matrix[(i * 3 + j)]) *
+            fRoot;
     out[k] =
-        (matrix[k * 3 + i] + matrix[i * 3 + k]) * fRoot;
+        (matrix[(k * 3 + i)] + matrix[(i * 3 + k)]) *
+            fRoot;
     return out;
-}
-export function fromEuler(x, y, z, out) {
+};
+/**
+ * Create a quaternion from equivalent X-Y-Z Tait-Bryan angles
+ * @param x - The X angle.
+ * @param y - The Y angle.
+ * @param z - The Z angle.
+ * @param out - The quaternion to store the result in.
+ * @returns The quaternion.
+ * @see [Euler angles](https://en.wikipedia.org/wiki/Euler_angles)
+ */
+export const fromEuler = (x, y, z, out) => {
     const r = (0.5 * Math.PI) / 180;
     const x2 = x * r;
     const y2 = y * r;
@@ -53,9 +77,18 @@ export function fromEuler(x, y, z, out) {
     out[2] = cx * cy * sz - sx * sy * cz;
     out[3] = cx * cy * cz + sx * sy * sz;
     return out;
-}
-const intermediary = new Float32Array(9);
-export function fromAxes(view, right, up, out) {
+};
+// Stores intermediary values for some functions.
+const intermediary = createMatrix3Like();
+/**
+ * Create a quaternion with values corresponding to the given orthonormal set of vectors.
+ * @param view - The vector representing the viewing direction.
+ * @param right - The vector representing the local "right" direction.
+ * @param up - The vector representing the local "up" direction.
+ * @param out - The quaternion to store the result in.
+ * @returns The quaternion.
+ */
+export const fromAxes = (view, right, up, out) => {
     intermediary[0] = right[0];
     intermediary[3] = right[1];
     intermediary[6] = right[2];
@@ -66,15 +99,26 @@ export function fromAxes(view, right, up, out) {
     intermediary[5] = -view[1];
     intermediary[8] = -view[2];
     return normalize(fromMatrix3(intermediary, out), out);
-}
-export function identity(out) {
+};
+/**
+ * Set a quaternion to the identity.
+ * @param out - The quaternion to store the result in.
+ * @returns This quaternion.
+ */
+export const identity = (out) => {
     out[0] = 0;
     out[1] = 0;
     out[2] = 0;
     out[3] = 1;
     return out;
-}
-export function getAxisAngle(quaternion, out) {
+};
+/**
+ * Calculate the axis and angle that represent a quaternion.
+ * @param quaternion - The quaternion.
+ * @param out - The axis and angle to store the result in.
+ * @returns The axis and angle.
+ */
+export const getAxisAngle = (quaternion, out) => {
     const r = Math.acos(quaternion[3]) * 2;
     const s = Math.sin(r / 2);
     out.axis =
@@ -83,8 +127,14 @@ export function getAxisAngle(quaternion, out) {
             : [1, 0, 0];
     out.angle = r;
     return out;
-}
-export function setAxisAngle(axisAngle, out) {
+};
+/**
+ * Set the axis and angle that represent a quaternion.
+ * @param axisAngle - The axis and angle.
+ * @param out - The quaternion to store the result in.
+ * @returns The quaternion.
+ */
+export const setAxisAngle = (axisAngle, out) => {
     const r = axisAngle.angle * 0.5;
     const s = Math.sin(r);
     out[0] = s * axisAngle.axis[0];
@@ -92,12 +142,25 @@ export function setAxisAngle(axisAngle, out) {
     out[2] = s * axisAngle.axis[2];
     out[3] = Math.cos(r);
     return out;
-}
-export function getAngle(a, b) {
+};
+/**
+ * Get the angular distance between two unit quaternions.
+ * @param a - The first unit quaternion.
+ * @param b - The second unit quaternion.
+ * @returns The angular distance in radians.
+ */
+export const getAngle = (a, b) => {
     const dp = dot(a, b);
     return Math.acos(2 * dp * dp - 1);
-}
-export function multiply(a, b, out) {
+};
+/**
+ * Multiply two quaternions.
+ * @param a - The multiplier.
+ * @param b - The multiplicand.
+ * @param out - The quaternion to store the result in.
+ * @returns The product.
+ */
+export const multiply = (a, b, out) => {
     const ax = a[0];
     const ay = a[1];
     const az = a[2];
@@ -111,8 +174,15 @@ export function multiply(a, b, out) {
     out[2] = az * bw + aw * bz + ax * by - ay * bx;
     out[3] = aw * bw - ax * bx - ay * by - az * bz;
     return out;
-}
-export function rotateX(quaternion, radians, out) {
+};
+/**
+ * Rotate a quaternion by the given angle around the X-axis.
+ * @param quaternion - The quaternion.
+ * @param radians - The angle in radians.
+ * @param out - The quaternion to store the result in.
+ * @returns The rotated quaternion.
+ */
+export const rotateX = (quaternion, radians, out) => {
     const r = radians * 0.5;
     const ax = quaternion[0];
     const ay = quaternion[1];
@@ -125,8 +195,15 @@ export function rotateX(quaternion, radians, out) {
     out[2] = az * bw - ay * bx;
     out[3] = aw * bw - ax * bx;
     return out;
-}
-export function rotateY(quaternion, radians, out) {
+};
+/**
+ * Rotate a quaternion by the given angle around the Y-axis.
+ * @param quaternion - The quaternion.
+ * @param radians - The angle in radians.
+ * @param out - The quaternion to store the result in.
+ * @returns The rotated quaternion.
+ */
+export const rotateY = (quaternion, radians, out) => {
     const r = radians * 0.5;
     const ax = quaternion[0];
     const ay = quaternion[1];
@@ -139,8 +216,15 @@ export function rotateY(quaternion, radians, out) {
     out[2] = az * bw + ax * by;
     out[3] = aw * bw - ay * by;
     return out;
-}
-export function rotateZ(quaternion, radians, out) {
+};
+/**
+ * Rotate a quaternion by the given angle around the Z-axis.
+ * @param quaternion - The quaternion.
+ * @param radians - The angle in radians.
+ * @param out - The quaternion to store the result in.
+ * @returns The rotated quaternion.
+ */
+export const rotateZ = (quaternion, radians, out) => {
     const r = radians * 0.5;
     const ax = quaternion[0];
     const ay = quaternion[1];
@@ -153,8 +237,14 @@ export function rotateZ(quaternion, radians, out) {
     out[2] = az * bw + aw * bz;
     out[3] = aw * bw - az * bz;
     return out;
-}
-export function calculateW(quaternion, out) {
+};
+/**
+ * Calculate the fourth component of a unit quaternion from the first three, ignoring the existing fourth component.
+ * @param quaternion - The quaternion.
+ * @param out - The quaternion to store the result in.
+ * @returns The quaternion.
+ */
+export const calculateW = (quaternion, out) => {
     const x = quaternion[0];
     const y = quaternion[1];
     const z = quaternion[2];
@@ -163,8 +253,14 @@ export function calculateW(quaternion, out) {
     out[2] = z;
     out[3] = Math.sqrt(Math.abs(1 - x * x - y * y - z * z));
     return out;
-}
-export function exp(quaternion, out) {
+};
+/**
+ * Calculate the exponential of a unit quaternion.
+ * @param quaternion - The quaternion.
+ * @param out - The quaternion to store the result in.
+ * @returns The exponential.
+ */
+export const exp = (quaternion, out) => {
     const x = quaternion[0];
     const y = quaternion[1];
     const z = quaternion[2];
@@ -177,8 +273,14 @@ export function exp(quaternion, out) {
     out[2] = z * s;
     out[3] = et * Math.cos(r);
     return out;
-}
-export function ln(quaternion, out) {
+};
+/**
+ * Calculate the natural logarithm of a unit quaternion.
+ * @param quaternion - The quaternion.
+ * @param out - The quaternion to store the result in.
+ * @returns The natural logarithm.
+ */
+export const ln = (quaternion, out) => {
     const x = quaternion[0];
     const y = quaternion[1];
     const z = quaternion[2];
@@ -190,11 +292,27 @@ export function ln(quaternion, out) {
     out[2] = z * t;
     out[3] = 0.5 * Math.log(x * x + y * y + z * z + w * w);
     return out;
-}
-export function pow(quaternion, scalar, out) {
+};
+/**
+ * Calculate a power of a unit quaternion.
+ * @param quaternion - The quaternion.
+ * @param scalar - The amount to scale the quaternion by.
+ * @param out - The quaternion to store the result in.
+ * @returns The power.
+ */
+export const pow = (quaternion, scalar, out) => {
     return exp(scale(ln(quaternion, out), scalar, out), out);
-}
-export function slerp(a, b, t, out) {
+};
+/**
+ * Perform a spherical linear interpolation between two quaternions.
+ * @param a - The first quaternion.
+ * @param b - The second quaternion.
+ * @param t - The interpolation amount in `[0,1]`.
+ * @param out - The quaternion to store the result in.
+ * @returns The interpolated quaternion.
+ * @see [Slerp](https://en.wikipedia.org/wiki/Slerp)
+ */
+export const slerp = (a, b, t, out) => {
     const ax = a[0];
     const ay = a[1];
     const az = a[2];
@@ -211,8 +329,10 @@ export function slerp(a, b, t, out) {
         bz = -bz;
         bw = -bw;
     }
-    let scale0 = 0;
-    let scale1 = 0;
+    // eslint-disable-next-line init-declarations
+    let scale0;
+    // eslint-disable-next-line init-declarations
+    let scale1;
     if (1 - cosom > epsilon) {
         const omega = Math.acos(cosom);
         const sinom = Math.sin(omega);
@@ -220,6 +340,7 @@ export function slerp(a, b, t, out) {
         scale1 = Math.sin(t * omega) / sinom;
     }
     else {
+        // Close enough to do a linear interpolation.
         scale0 = 1 - t;
         scale1 = t;
     }
@@ -228,8 +349,13 @@ export function slerp(a, b, t, out) {
     out[2] = scale0 * az + scale1 * bz;
     out[3] = scale0 * aw + scale1 * bw;
     return out;
-}
-export function random(out) {
+};
+/**
+ * Set a quaternion to a random unit quaternion.
+ * @param out - The quaternion to store the result in.
+ * @returns The quaternion.
+ */
+export const random = (out) => {
     const u1 = Math.random();
     const u2 = Math.random();
     const u3 = Math.random();
@@ -240,15 +366,21 @@ export function random(out) {
     out[2] = sqrtU1 * Math.sin(2 * Math.PI * u3);
     out[3] = sqrtU1 * Math.cos(2 * Math.PI * u3);
     return out;
-}
-export function invert(quaternion, out) {
+};
+/**
+ * Calculate the inverse of a quaternion. If the quaternion is normalized, the conjugate is the same but faster to calculate.
+ * @param quaternion - The quaternion.
+ * @param out - The quaternion to store the result in.
+ * @returns The inverse.
+ */
+export const invert = (quaternion, out) => {
     const a0 = quaternion[0];
     const a1 = quaternion[1];
     const a2 = quaternion[2];
     const a3 = quaternion[3];
-    const dot = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;
-    const invDot = dot ? 1 / dot : 0;
-    if (dot == 0) {
+    const aDotA = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;
+    const invDot = aDotA ? 1 / aDotA : 0;
+    if (aDotA === 0) {
         out[0] = 0;
         out[1] = 0;
         out[2] = 0;
@@ -260,119 +392,333 @@ export function invert(quaternion, out) {
     out[2] = -a2 * invDot;
     out[3] = a3 * invDot;
     return out;
-}
-export function conjugate(quaternion, out) {
+};
+/**
+ * Calculate the conjugate of a quaternion. If the quaternion is normalized, this is the same as the inverse but faster to calculate.
+ * @param quaternion - The quaternion.
+ * @param out - The quaternion to store the result in.
+ * @returns The conjugate.
+ */
+export const conjugate = (quaternion, out) => {
     out[0] = -quaternion[0];
     out[1] = -quaternion[1];
     out[2] = -quaternion[2];
     out[3] = quaternion[3];
     return out;
-}
-const controlPointOne = new Float32Array(4);
-const controlPointTwo = new Float32Array(4);
-export function sqlerp(a, b, c, d, t, out) {
+};
+// Used to store intermediate values for some functions.
+const controlPointOne = createQuaternionLike();
+const controlPointTwo = createQuaternionLike();
+/**
+ * Perform a spherical linear interpolation with two control points between two quaternions.
+ * @param a - The first quaternion.
+ * @param b - The first control point.
+ * @param c - The second control point.
+ * @param d - The second quaternion.
+ * @param t - The interpolation amount in `[0,1]`.
+ * @param out - The quaternion to store the result in.
+ * @returns The interpolated value.
+ * @see [Slerp](https://en.wikipedia.org/wiki/Slerp)
+ */
+export const sqlerp = (a, b, c, d, t, out) => {
     slerp(a, d, t, controlPointOne);
     slerp(b, c, t, controlPointTwo);
     return slerp(controlPointOne, controlPointTwo, 2 * t * (1 - t), out);
-}
+};
+/**
+ * A complex number that is commonly used to describe rotations.
+ * @see [Quaternion](https://en.wikipedia.org/wiki/Quaternion)
+ */
 export default class Quaternion extends Float32Array {
+    /**
+     * Create a quaternion from a three-by-three rotation matrix.
+     * @param matrix - The matrix.
+     * @param out - The quaternion to store the result in.
+     * @returns The quaternion.
+     * @see [Rotation matrix](https://en.wikipedia.org/wiki/Rotation_matrix)
+     */
     static fromMatrix3(matrix, out = new Quaternion()) {
         return fromMatrix3(matrix, out);
     }
+    /**
+     * Create a quaternion from equivalent x-y-z Tait-Bryan angles
+     * @param x - The x angle.
+     * @param y - The y angle.
+     * @param z - The z angle.
+     * @param out - The quaternion to store the result in.
+     * @returns The quaternion.
+     * @see [Euler angles](https://en.wikipedia.org/wiki/Euler_angles)
+     */
     static fromEuler(x, y, z, out = new Quaternion()) {
         return fromEuler(x, y, z, out);
     }
+    /**
+     * Create a quaternion with the given values.
+     * @param x - The first component.
+     * @param y - The second component.
+     * @param z - The third component.
+     * @param w - The fourth component.
+     * @param out - The quaternion to store the result in.
+     * @returns A new quaternion.
+     */
     static fromValues(x, y, z, w, out = new Quaternion()) {
         return fromValues(x, y, z, w, out);
     }
+    /**
+     * Create a quaternion with values corresponding to the given orthonormal set of vectors.
+     * @param view - The vector representing the viewing direction.
+     * @param right - The vector representing the local "right" direction.
+     * @param up - The vector representing the local "up" direction.
+     * @param out - The quaternion to store the result in.
+     * @returns The quaternion.
+     */
     static fromAxes(view, right, up, out = new Quaternion()) {
         return fromAxes(view, right, up, out);
     }
+    /**
+     * Create an identity quaternion.
+     * @see [Quaternion](https://en.wikipedia.org/wiki/Quaternion)
+     */
     constructor() {
         super(4);
         this[3] = 1;
     }
+    /** The first component of this quaternion. */
+    0;
+    /** The second component of this quaternion. */
+    1;
+    /** The third component of this quaternion. */
+    2;
+    /** The fourth component of this quaternion. */
+    3;
+    /**
+     * Set this quaternion to the identity.
+     * @returns This quaternion.
+     */
     identity() {
         return identity(this);
     }
+    /**
+     * Get the axis and angle that represent this quaternion.
+     * @param out - The axis and angle to store the result in.
+     * @returns The axis and angle.
+     */
     getAxisAngle(out = {}) {
         return getAxisAngle(this, out);
     }
+    /**
+     * Set the axis and angle that represent this quaternion.
+     * @param axisAngle - The axis and angle.
+     * @returns This quaternion.
+     */
     setAxisAngle(axisAngle) {
         return setAxisAngle(axisAngle, this);
     }
+    /**
+     * Get the angular distance between this unit quaternion and another.
+     * @param quaternion - The other unit quaternion.
+     * @returns The angular distance in radians.
+     */
     getAngle(quaternion) {
         return getAngle(this, quaternion);
     }
+    /**
+     * Multiply this and another quaternion.
+     * @param quaternion - The other quaternion.
+     * @param out - The quaternion to store the result in.
+     * @returns The product.
+     */
     multiply(quaternion, out = new Quaternion()) {
         return multiply(this, quaternion, out);
     }
-    rotateX(radians, out = new Quaternion()) {
-        return rotateX(this, radians, out);
-    }
-    rotateY(radians, out = new Quaternion()) {
-        return rotateY(this, radians, out);
-    }
-    rotateZ(radians, out = new Quaternion()) {
-        return rotateZ(this, radians, out);
-    }
+    /**
+     * Rotate this quaternion by the given angle around the X-axis.
+     * @param r - The angle in radians.
+     * @param out - The quaternion to store the result in.
+     * @returns The rotated quaternion.
+     */
+    rotateX(r, out = new Quaternion()) {
+        return rotateX(this, r, out);
+    }
+    /**
+     * Rotate this quaternion by the given angle around the Y-axis.
+     * @param r - The angle in radians.
+     * @param out - The quaternion to store the result in.
+     * @returns The rotated quaternion.
+     */
+    rotateY(r, out = new Quaternion()) {
+        return rotateY(this, r, out);
+    }
+    /**
+     * Rotate this quaternion by the given angle around the Z-axis.
+     * @param r - The angle in radians.
+     * @param out - The quaternion to store the result in.
+     * @returns The rotated quaternion.
+     */
+    rotateZ(r, out = new Quaternion()) {
+        return rotateZ(this, r, out);
+    }
+    /**
+     * Calculate the fourth component of this unit quaternion from the first three, ignoring the existing fourth component.
+     * @param out - The quaternion to store the result in.
+     * @returns The quaternion.
+     */
     calculateW(out = new Quaternion()) {
         return calculateW(this, out);
     }
+    /**
+     * Calculate the exponential of this unit quaternion.
+     * @param out - The quaternion to store the result in.
+     * @returns The exponential.
+     */
     exp(out = new Quaternion()) {
         return exp(this, out);
     }
+    /**
+     * Calculate the natural logarithm of this unit quaternion.
+     * @param out - The quaternion to store the result in.
+     * @returns The natural logarithm.
+     */
     ln(out = new Quaternion()) {
         return ln(this, out);
     }
+    /**
+     * Calculate a power of this unit quaternion.
+     * @param scalar - The amount to scale the quaternion by.
+     * @param out - The quaternion to store the result in.
+     * @returns The power.
+     */
     pow(scalar, out = new Quaternion()) {
         return pow(this, scalar, out);
     }
+    /**
+     * Perform a spherical linear interpolation between this and another quaternion.
+     * @param quaternion - The other quaternion.
+     * @param t - The interpolation amount in `[0,1]`.
+     * @param out - The quaternion to store the result in.
+     * @returns The interpolated quaternion.
+     * @see [Slerp](https://en.wikipedia.org/wiki/Slerp)
+     */
     slerp(quaternion, t, out = new Quaternion()) {
         return slerp(this, quaternion, t, out);
     }
+    /**
+     * Set this to a random unit quaternion.
+     * @returns A random unit quaternion.
+     */
     random() {
         return random(this);
     }
+    /**
+     * Calculate the inverse of this quaternion. If the quaternion is normalized, the conjugate is the same but faster to calculate.
+     * @param out - The quaternion to store the result in.
+     * @returns The inverse.
+     */
     invert(out = new Quaternion()) {
         return invert(this, out);
     }
+    /**
+     * Calculate the conjugate of this quaternion. If the quaternion is normalized, this is the same as the inverse but faster to calculate.
+     * @param out - The quaternion to store the result in.
+     * @returns The conjugate.
+     */
     conjugate(out = new Quaternion()) {
         return conjugate(this, out);
     }
+    /**
+     * Copy the values from this quaternion to another one.
+     * @param out - The quaternion to store the result in.
+     * @returns The copy.
+     */
     clone(out = new Quaternion()) {
         return copy(this, out);
     }
+    /**
+     * Copy the values of another quaternion into this one.
+     * @param quaternion - The quaternion to copy.
+     * @returns This quaternion.
+     */
     copy(quaternion) {
         return copy(quaternion, this);
     }
+    /**
+     * Add two quaternions of the same size.
+     * @param quaternion - The other quaternion.
+     * @param out - The quaternion to store the result in.
+     * @returns The sum of the quaternions.
+     */
     add(quaternion, out = new Quaternion()) {
         return add(this, quaternion, out);
     }
+    /**
+     * Scale this quaternion by a scalar.
+     * @param scalar - The scalar.
+     * @param out - The quaternion to store the result in.
+     * @returns The scaled quaternion.
+     */
     scale(scalar, out = new Quaternion()) {
         return scale(this, scalar, out);
     }
+    /**
+     * Calculate the dot product of this and another quaternion.
+     * @param quaternion - The other quaternion.
+     * @returns The dot product.
+     */
     dot(quaternion) {
         return dot(this, quaternion);
     }
+    /**
+     * Perform a linear interpolation between this and another quaternion.
+     * @param quaternion - The other quaternion.
+     * @param t - The interpolation amount (in `[0,1]`).
+     * @param out - The quaternion to store the result in.
+     * @returns The interpolated quaternion.
+     */
     lerp(quaternion, t, out = new Quaternion()) {
         return lerp(this, quaternion, t, out);
     }
+    /** Get the magnitude (length) of this quaternion. */
     get magnitude() {
         return getMagnitude(this);
     }
+    /** Get the squared magnitude (length) of this quaternion. */
     get squaredMagnitude() {
         return getSquaredMagnitude(this);
     }
+    /**
+     * Normalize this quaternion.
+     * @param out - The quaternion to store the result in.
+     * @returns The normalized quaternion.
+     */
     normalize(out = new Quaternion()) {
         return normalize(this, out);
     }
+    /**
+     * Determine whether or not this quaternion is roughly equivalent to another.
+     * @param quaternion - The other quaternion.
+     * @returns Whether or not the quaternions are equivalent.
+     */
     equals(quaternion) {
         return equals(this, quaternion);
     }
+    /**
+     * Determine whether or not this quaternion is exactly equivalent to another.
+     * @param quaternion - The other quaternion.
+     * @returns Whether or not the quaternions are equivalent.
+     */
     exactEquals(quaternion) {
         return exactEquals(this, quaternion);
     }
+    /**
+     * Perform a spherical linear interpolation with two control points between this and another quaternion.
+     * @param a - The first control point.
+     * @param b - The second control point.
+     * @param quaternion - The other quaternion.
+     * @param t - The interpolation amount in `[0,1]`.
+     * @param out - The quaternion to store the result in.
+     * @returns The interpolated value.
+     * @see [Slerp](https://en.wikipedia.org/wiki/Slerp)
+     */
     sqlerp(a, b, quaternion, t, out = new Quaternion()) {
         return sqlerp(this, a, b, quaternion, t, out);
     }