@math.gl/core 3.5.6 → 3.6.0-alpha.2

package/dist/lib/common.js

@@ -0,0 +1,210 @@
+import assert from './assert';
+const RADIANS_TO_DEGREES = (1 / Math.PI) * 180;
+const DEGREES_TO_RADIANS = (1 / 180) * Math.PI;
+// TODO - remove
+/* eslint-disable no-shadow */
+export const config = {};
+config.EPSILON = 1e-12;
+config.debug = false;
+config.precision = 4;
+config.printTypes = false;
+config.printDegrees = false;
+config.printRowMajor = true;
+export function configure(options = {}) {
+    // Only copy existing keys
+    for (const key in options) {
+        assert(key in config);
+        config[key] = options[key];
+    }
+    return config;
+}
+/**
+ * Formats a value into a string
+ * @param value
+ * @param param1
+ * @returns
+ */
+export function formatValue(value, { precision = config.precision || 4 } = {}) {
+    value = round(value);
+    // get rid of trailing zeros
+    return `${parseFloat(value.toPrecision(precision))}`;
+}
+/**
+ * Check if value is an "array"
+ * Returns `true` if value is either an array or a typed array
+ *
+ * Note: returns `false` for `ArrayBuffer` and `DataView` instances
+ */
+export function isArray(value) {
+    return Array.isArray(value) || (ArrayBuffer.isView(value) && !(value instanceof DataView));
+}
+export function clone(array) {
+    return 'clone' in array ? array.clone() : array.slice();
+}
+export function toRadians(degrees) {
+    return radians(degrees);
+}
+export function toDegrees(radians) {
+    return degrees(radians);
+}
+export function radians(degrees, result) {
+    return map(degrees, (degrees) => degrees * DEGREES_TO_RADIANS, result);
+}
+export function degrees(radians, result) {
+    return map(radians, (radians) => radians * RADIANS_TO_DEGREES, result);
+}
+/**
+ * "GLSL equivalent" of `Math.sin`: Works on single values and vectors
+ * @deprecated
+ */
+export function sin(radians, result) {
+    return map(radians, (angle) => Math.sin(angle), result);
+}
+/**
+ * "GLSL equivalent" of `Math.cos`: Works on single values and vectors
+ * @deprecated
+ */
+export function cos(radians, result) {
+    return map(radians, (angle) => Math.cos(angle), result);
+}
+/**
+ * "GLSL equivalent" of `Math.tan`: Works on single values and vectors
+ * @deprecated
+ */
+export function tan(radians, result) {
+    return map(radians, (angle) => Math.tan(angle), result);
+}
+/**
+ * "GLSL equivalent" of `Math.asin`: Works on single values and vectors
+ * @deprecated
+ */
+export function asin(radians, result) {
+    return map(radians, (angle) => Math.asin(angle), result);
+}
+/**
+ * "GLSL equivalent" of `Math.acos`: Works on single values and vectors
+ * @deprecated
+ */
+export function acos(radians, result) {
+    return map(radians, (angle) => Math.acos(angle), result);
+}
+/**
+ * "GLSL equivalent" of `Math.atan`: Works on single values and vectors
+ * @deprecated
+ */
+export function atan(radians, result) {
+    return map(radians, (angle) => Math.atan(angle), result);
+}
+export function clamp(value, min, max) {
+    return map(value, (value) => Math.max(min, Math.min(max, value)));
+}
+export function lerp(a, b, t) {
+    if (isArray(a)) {
+        return a.map((ai, i) => lerp(ai, b[i], t));
+    }
+    return t * b + (1 - t) * a;
+}
+/* eslint-disable */
+/**
+ * Compares any two math objects, using `equals` method if available.
+ * @param a
+ * @param b
+ * @param epsilon
+ * @returns
+ */
+export function equals(a, b, epsilon) {
+    const oldEpsilon = config.EPSILON;
+    if (epsilon) {
+        config.EPSILON = epsilon;
+    }
+    try {
+        if (a === b) {
+            return true;
+        }
+        if (isArray(a) && isArray(b)) {
+            if (a.length !== b.length) {
+                return false;
+            }
+            for (let i = 0; i < a.length; ++i) {
+                // eslint-disable-next-line max-depth
+                if (!equals(a[i], b[i])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (a && a.equals) {
+            return a.equals(b);
+        }
+        if (b && b.equals) {
+            return b.equals(a);
+        }
+        if (typeof a === 'number' && typeof b === 'number') {
+            return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
+        }
+        return false;
+    }
+    finally {
+        config.EPSILON = oldEpsilon;
+    }
+}
+export function exactEquals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a && typeof a === 'object' && b && typeof b === 'object') {
+        if (a.constructor !== b.constructor) {
+            return false;
+        }
+        if (a.exactEquals) {
+            return a.exactEquals(b);
+        }
+    }
+    if (isArray(a) && isArray(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; ++i) {
+            if (!exactEquals(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+/* eslint-enable */
+export function withEpsilon(epsilon, func) {
+    const oldPrecision = config.EPSILON;
+    config.EPSILON = epsilon;
+    let value;
+    try {
+        value = func();
+    }
+    finally {
+        config.EPSILON = oldPrecision;
+    }
+    return value;
+}
+// HELPERS
+function round(value) {
+    return Math.round(value / config.EPSILON) * config.EPSILON;
+}
+// If the array has a clone function, calls it, otherwise returns a copy
+function duplicateArray(array) {
+    // @ts-expect-error We check for math.gl class methods
+    return array.clone ? array.clone() : new Array(array.length);
+}
+// If the argument value is an array, applies the func element wise,
+// otherwise applies func to the argument value
+function map(value, func, result) {
+    if (isArray(value)) {
+        const array = value;
+        result = result || duplicateArray(array);
+        for (let i = 0; i < result.length && i < array.length; ++i) {
+            result[i] = func(value[i], i, result);
+        }
+        return result;
+    }
+    return func(value);
+}

package/dist/lib/gl-matrix-extras.d.ts

@@ -0,0 +1,7 @@
+import { NumericArray } from '@math.gl/types';
+export declare function vec2_transformMat4AsVector<T extends NumericArray>(out: T, a: Readonly<NumericArray>, m: Readonly<NumericArray>): T;
+export declare function vec3_transformMat4AsVector<T extends NumericArray>(out: T, a: Readonly<NumericArray>, m: Readonly<NumericArray>): T;
+export declare function vec3_transformMat2<T extends NumericArray>(out: T, a: Readonly<NumericArray>, m: Readonly<NumericArray>): T;
+export declare function vec4_transformMat2<T extends NumericArray>(out: T, a: Readonly<NumericArray>, m: Readonly<NumericArray>): T;
+export declare function vec4_transformMat3<T extends NumericArray>(out: T, a: Readonly<NumericArray>, m: Readonly<NumericArray>): T;
+//# sourceMappingURL=gl-matrix-extras.d.ts.map

package/dist/lib/gl-matrix-extras.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gl-matrix-extras.d.ts","sourceRoot":"","sources":["../../src/lib/gl-matrix-extras.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAG5C,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,YAAY,EAC/D,GAAG,EAAE,CAAC,EACN,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,EACzB,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,GACxB,CAAC,CAOH;AAKD,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,YAAY,EAC/D,GAAG,EAAE,CAAC,EACN,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,EACzB,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,GACxB,CAAC,CASH;AAED,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,YAAY,EACvD,GAAG,EAAE,CAAC,EACN,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,EACzB,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,GACxB,CAAC,CAOH;AAID,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,YAAY,EACvD,GAAG,EAAE,CAAC,EACN,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,EACzB,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,GACxB,CAAC,CAQH;AAED,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,YAAY,EACvD,GAAG,EAAE,CAAC,EACN,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,EACzB,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,GACxB,CAAC,CASH"}

package/dist/lib/gl-matrix-extras.js

@@ -0,0 +1,49 @@
+// vec2 additions
+export function vec2_transformMat4AsVector(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const w = m[3] * x + m[7] * y || 1.0;
+    out[0] = (m[0] * x + m[4] * y) / w;
+    out[1] = (m[1] * x + m[5] * y) / w;
+    return out;
+}
+// vec3 additions
+// Transform as vector, only uses 3x3 minor matrix
+export function vec3_transformMat4AsVector(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    const w = m[3] * x + m[7] * y + m[11] * z || 1.0;
+    out[0] = (m[0] * x + m[4] * y + m[8] * z) / w;
+    out[1] = (m[1] * x + m[5] * y + m[9] * z) / w;
+    out[2] = (m[2] * x + m[6] * y + m[10] * z) / w;
+    return out;
+}
+export function vec3_transformMat2(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    out[0] = m[0] * x + m[2] * y;
+    out[1] = m[1] * x + m[3] * y;
+    out[2] = a[2];
+    return out;
+}
+// vec4 additions
+export function vec4_transformMat2(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    out[0] = m[0] * x + m[2] * y;
+    out[1] = m[1] * x + m[3] * y;
+    out[2] = a[2];
+    out[3] = a[3];
+    return out;
+}
+export function vec4_transformMat3(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    out[0] = m[0] * x + m[3] * y + m[6] * z;
+    out[1] = m[1] * x + m[4] * y + m[7] * z;
+    out[2] = m[2] * x + m[5] * y + m[8] * z;
+    out[3] = a[3];
+    return out;
+}

package/dist/lib/math-utils.d.ts

@@ -0,0 +1,28 @@
+declare const _default: {
+    EPSILON1: number;
+    EPSILON2: number;
+    EPSILON3: number;
+    EPSILON4: number;
+    EPSILON5: number;
+    EPSILON6: number;
+    EPSILON7: number;
+    EPSILON8: number;
+    EPSILON9: number;
+    EPSILON10: number;
+    EPSILON11: number;
+    EPSILON12: number;
+    EPSILON13: number;
+    EPSILON14: number;
+    EPSILON15: number;
+    EPSILON16: number;
+    EPSILON17: number;
+    EPSILON18: number;
+    EPSILON19: number;
+    EPSILON20: number;
+    PI_OVER_TWO: number;
+    PI_OVER_FOUR: number;
+    PI_OVER_SIX: number;
+    TWO_PI: number;
+};
+export default _default;
+//# sourceMappingURL=math-utils.d.ts.map

package/dist/lib/math-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math-utils.d.ts","sourceRoot":"","sources":["../../src/lib/math-utils.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,wBA2BE"}

package/dist/lib/math-utils.js

@@ -0,0 +1,28 @@
+// NOTE: Added to make Cesium-derived test cases work
+// TODO: Determine if/how to keep
+export default {
+    EPSILON1: 1e-1,
+    EPSILON2: 1e-2,
+    EPSILON3: 1e-3,
+    EPSILON4: 1e-4,
+    EPSILON5: 1e-5,
+    EPSILON6: 1e-6,
+    EPSILON7: 1e-7,
+    EPSILON8: 1e-8,
+    EPSILON9: 1e-9,
+    EPSILON10: 1e-10,
+    EPSILON11: 1e-11,
+    EPSILON12: 1e-12,
+    EPSILON13: 1e-13,
+    EPSILON14: 1e-14,
+    EPSILON15: 1e-15,
+    EPSILON16: 1e-16,
+    EPSILON17: 1e-17,
+    EPSILON18: 1e-18,
+    EPSILON19: 1e-19,
+    EPSILON20: 1e-20,
+    PI_OVER_TWO: Math.PI / 2,
+    PI_OVER_FOUR: Math.PI / 4,
+    PI_OVER_SIX: Math.PI / 6,
+    TWO_PI: Math.PI * 2
+};

package/dist/lib/validators.d.ts

@@ -0,0 +1,6 @@
+import { NumberArray } from '@math.gl/types';
+export declare function validateVector(v: NumberArray, length: number): boolean;
+export declare function checkNumber(value: any): number;
+export declare function checkVector<T extends NumberArray>(v: T, length: number, callerName?: string): T;
+export declare function deprecated(method: string, version: string): void;
+//# sourceMappingURL=validators.d.ts.map

package/dist/lib/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../src/lib/validators.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAG3C,wBAAgB,cAAc,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAWtE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,CAK9C;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,WAAW,EAC/C,CAAC,EAAE,CAAC,EACJ,MAAM,EAAE,MAAM,EACd,UAAU,GAAE,MAAW,GACtB,CAAC,CAKH;AAID,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAQhE"}

package/dist/lib/validators.js

@@ -0,0 +1,33 @@
+import { config } from './common';
+export function validateVector(v, length) {
+    if (v.length !== length) {
+        return false;
+    }
+    // Could be arguments "array" (v.every not availasble)
+    for (let i = 0; i < v.length; ++i) {
+        if (!Number.isFinite(v[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+export function checkNumber(value) {
+    if (!Number.isFinite(value)) {
+        throw new Error(`Invalid number ${value}`);
+    }
+    return value;
+}
+export function checkVector(v, length, callerName = '') {
+    if (config.debug && !validateVector(v, length)) {
+        throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
+    }
+    return v;
+}
+const map = {};
+export function deprecated(method, version) {
+    if (!map[method]) {
+        map[method] = true;
+        // eslint-disable-next-line
+        console.warn(`${method} has been removed in version ${version}, see upgrade guide for more information`);
+    }
+}

package/package.json

@@ -5,7 +5,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.5.6",
+  "version": "3.6.0-alpha.2",
   "keywords": [
     "webgl",
     "javascript",
@@ -26,7 +26,7 @@
     "type": "git",
     "url": "https://github.com/uber-web/math.gl.git"
   },
-  "types": "src/index.d.ts",
+  "types": "src/index.ts",
   "main": "dist/es5/index.js",
   "module": "dist/esm/index.js",
   "files": [
@@ -38,7 +38,8 @@
   ],
   "dependencies": {
     "@babel/runtime": "^7.12.0",
-    "gl-matrix": "~3.3.0"
+    "@math.gl/types": "3.6.0-alpha.2",
+    "gl-matrix": "^3.4.0"
   },
-  "gitHead": "0e69c70ff2e6373fed84d303cbf8198a6972944f"
+  "gitHead": "ea7dc265c98b68af56218302d1d42b7d65f74ccb"
 }

package/src/classes/base/math-array.ts

@@ -0,0 +1,265 @@
+// math.gl, MIT License
+import {NumericArray} from '@math.gl/types';
+import {ConfigurationOptions, config, formatValue, equals, isArray} from '../../lib/common';
+
+/** Base class for vectors and matrices */
+export default abstract class MathArray extends Array<number> {
+  /** Number of elements (values) in this array */
+  abstract get ELEMENTS(): number;
+
+  abstract copy(vector: Readonly<NumericArray>): this;
+
+  abstract fromObject(object: object): this;
+
+  // Common methods
+
+  /**
+   * Clone the current object
+   * @returns a new copy of this object
+   */
+  clone(): this {
+    // @ts-expect-error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
+    return new this.constructor().copy(this); // eslint-disable-line
+  }
+
+  fromArray(array: Readonly<NumericArray>, offset: number = 0): this {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] = array[i + offset];
+    }
+    return this.check();
+  }
+
+  toArray<TypedArray>(targetArray: TypedArray, offset?: number): TypedArray;
+  toArray(targetArray?: number[], offset?: number): NumericArray;
+
+  toArray(targetArray: NumericArray = [], offset: number = 0): NumericArray {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      targetArray[offset + i] = this[i];
+    }
+    return targetArray;
+  }
+
+  from(arrayOrObject: Readonly<NumericArray> | object): this {
+    return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+  }
+
+  to<T extends NumericArray | object>(arrayOrObject: T): T {
+    // @ts-ignore
+    if (arrayOrObject === this) {
+      return this;
+    }
+    // @ts-expect-error TS2339: Property 'toObject' does not exist on type 'MathArray'.
+    return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
+  }
+
+  toTarget(target: any): any {
+    return target ? this.to(target) : this;
+  }
+
+  /** @deprecated */
+  toFloat32Array(): Float32Array {
+    return new Float32Array(this);
+  }
+
+  toString(): string {
+    return this.formatString(config);
+  }
+
+  /** Formats string according to options */
+  formatString(opts: ConfigurationOptions): string {
+    let string = '';
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      string += (i > 0 ? ', ' : '') + formatValue(this[i], opts);
+    }
+    return `${opts.printTypes ? this.constructor.name : ''}[${string}]`;
+  }
+
+  equals(array: Readonly<NumericArray>): boolean {
+    if (!array || this.length !== array.length) {
+      return false;
+    }
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      if (!equals(this[i], array[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  exactEquals(array: Readonly<NumericArray>): boolean {
+    if (!array || this.length !== array.length) {
+      return false;
+    }
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      if (this[i] !== array[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // Modifiers
+
+  /** Negates all values in this object */
+  negate(): this {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] = -this[i];
+    }
+    return this.check();
+  }
+
+  /** Linearly interpolates between two values */
+  lerp(a: Readonly<NumericArray>, t: number): this;
+  lerp(a: Readonly<NumericArray>, b: Readonly<NumericArray>, t: number): this;
+
+  lerp(a: Readonly<NumericArray>, b: Readonly<NumericArray> | number, t?: number): this {
+    if (t === undefined) {
+      return this.lerp(this, a, b as number);
+    }
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      const ai = a[i];
+      this[i] = ai + t * (b[i] - ai);
+    }
+    return this.check();
+  }
+
+  /** Minimal */
+  min(vector: Readonly<NumericArray>): this {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] = Math.min(vector[i], this[i]);
+    }
+    return this.check();
+  }
+
+  /** Maximal */
+  max(vector: Readonly<NumericArray>): this {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] = Math.max(vector[i], this[i]);
+    }
+    return this.check();
+  }
+
+  clamp(minVector: Readonly<NumericArray>, maxVector: Readonly<NumericArray>): this {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]);
+    }
+    return this.check();
+  }
+
+  add(...vectors: Readonly<NumericArray>[]): this {
+    for (const vector of vectors) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] += vector[i];
+      }
+    }
+    return this.check();
+  }
+
+  subtract(...vectors: Readonly<NumericArray>[]): this {
+    for (const vector of vectors) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] -= vector[i];
+      }
+    }
+    return this.check();
+  }
+
+  scale(scale: number | Readonly<NumericArray>): this {
+    if (typeof scale === 'number') {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] *= scale;
+      }
+    } else {
+      for (let i = 0; i < this.ELEMENTS && i < scale.length; ++i) {
+        this[i] *= scale[i];
+      }
+    }
+    return this.check();
+  }
+
+  /**
+   * Multiplies all elements by `scale`
+   * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
+   */
+  multiplyByScalar(scalar: number): this {
+    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(): this {
+    if (config.debug && !this.validate()) {
+      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(): boolean {
+    let valid = this.length === this.ELEMENTS;
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      valid = valid && Number.isFinite(this[i]);
+    }
+    return valid;
+  }
+
+  // three.js compatibility
+
+  /** @deprecated */
+  sub(a: Readonly<NumericArray>): this {
+    return this.subtract(a);
+  }
+
+  /** @deprecated */
+  setScalar(a: number): this {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] = a;
+    }
+    return this.check();
+  }
+
+  /** @deprecated */
+  addScalar(a: number): this {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] += a;
+    }
+    return this.check();
+  }
+
+  /** @deprecated */
+  subScalar(a: number): this {
+    return this.addScalar(-a);
+  }
+
+  /** @deprecated */
+  multiplyScalar(scalar: number): this {
+    // Multiplies all elements
+    // `Matrix4.scale` only scales its 3x3 "minor"
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] *= scalar;
+    }
+    return this.check();
+  }
+
+  /** @deprecated */
+  divideScalar(a: number): this {
+    return this.multiplyByScalar(1 / a);
+  }
+
+  /** @deprecated */
+  clampScalar(min: number, max: number): this {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] = Math.min(Math.max(this[i], min), max);
+    }
+    return this.check();
+  }
+
+  /** @deprecated */
+  get elements(): NumericArray {
+    return this;
+  }
+}