@math.gl/core 4.2.0-alpha.6 → 5.0.0-alpha.2

package/src/classes/euler.ts

@@ -4,19 +4,19 @@
 // Copyright (c) 2017 Uber Technologies, Inc.
 
 import {MathArray} from './base/math-array';
-import {Quaternion} from './quaternion';
 import {NumericArray} from '@math.gl/types';
+import type {EulerRotationOrder} from './euler-types';
 
 import {clamp} from '../lib/common';
 import {checkNumber} from '../lib/validators';
+import {fromQuat as mat4_fromQuat} from '../gl-matrix/mat4';
+
+export type {EulerLike, EulerRotationOrder} from './euler-types';
 
 // Internal constants
 const ERR_UNKNOWN_ORDER = 'Unknown Euler angle order';
 const ALMOST_ONE = 0.99999;
 
-/** Order in which Euler rotations are applied. */
-export type EulerRotationOrder = 'zyx' | 'yxz' | 'xzy' | 'zxy' | 'yzx' | 'xyz';
-
 enum RotationOrderIndex {
   ZYX = 0,
   YXZ = 1,
@@ -35,57 +35,7 @@ const ROTATION_ORDER_INDICES: Record<EulerRotationOrder, RotationOrderIndex> = {
   xyz: RotationOrderIndex.XYZ
 };
 
-const ROTATION_ORDERS = {
-  ZYX: 'zyx',
-  YXZ: 'yxz',
-  XZY: 'xzy',
-  ZXY: 'zxy',
-  YZX: 'yzx',
-  XYZ: 'xyz'
-} as const;
-
 export class Euler extends MathArray {
-  // Constants
-  /** @deprecated Pass the string `'zyx'` directly. */
-  static get ZYX(): EulerRotationOrder {
-    return 'zyx';
-  }
-  /** @deprecated Pass the string `'yxz'` directly. */
-  static get YXZ(): EulerRotationOrder {
-    return 'yxz';
-  }
-  /** @deprecated Pass the string `'xzy'` directly. */
-  static get XZY(): EulerRotationOrder {
-    return 'xzy';
-  }
-  /** @deprecated Pass the string `'zxy'` directly. */
-  static get ZXY(): EulerRotationOrder {
-    return 'zxy';
-  }
-  /** @deprecated Pass the string `'yzx'` directly. */
-  static get YZX(): EulerRotationOrder {
-    return 'yzx';
-  }
-  /** @deprecated Pass the string `'xyz'` directly. */
-  static get XYZ(): EulerRotationOrder {
-    return 'xyz';
-  }
-  /** @deprecated Pass the string `'zyx'` directly. */
-  static get RollPitchYaw(): EulerRotationOrder {
-    return 'zyx';
-  }
-  /** @deprecated Pass the string `'zyx'` directly. */
-  static get DefaultOrder(): EulerRotationOrder {
-    return 'zyx';
-  }
-  /** @deprecated Pass an {@link EulerRotationOrder} string directly. */
-  static get RotationOrders(): typeof ROTATION_ORDERS {
-    return ROTATION_ORDERS;
-  }
-  /** @deprecated Euler rotation orders are already represented as strings. */
-  static rotationOrder(order: EulerRotationOrder): EulerRotationOrder {
-    return order;
-  }
   get ELEMENTS(): number {
     return 4;
   }
@@ -110,20 +60,9 @@ export class Euler extends MathArray {
     }
   }
 
-  fromQuaternion(quaternion: Readonly<NumericArray>): this {
-    const [x, y, z, w] = quaternion;
-    const ysqr = y * y;
-    const t0 = -2 * (ysqr + z * z) + 1;
-    const t1 = +2 * (x * y + w * z);
-    let t2 = -2 * (x * z - w * y);
-    const t3 = +2 * (y * z + w * x);
-    const t4 = -2 * (x * x + ysqr) + 1;
-    t2 = t2 > 1 ? 1 : t2;
-    t2 = t2 < -1 ? -1 : t2;
-    const roll = Math.atan2(t3, t4);
-    const pitch = Math.asin(t2);
-    const yaw = Math.atan2(t1, t0);
-    return this.set(roll, pitch, yaw, 'zyx');
+  fromQuaternion(quaternion: Readonly<NumericArray>, order: EulerRotationOrder = this.order): this {
+    const matrix = mat4_fromQuat(new Array<number>(16), quaternion);
+    return this.fromRotationMatrix(matrix, order);
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -307,36 +246,17 @@ export class Euler extends MathArray {
     return this.set(roll, pitch, yaw, 'zyx');
   }
 
-  fromRotationMatrix(m: Readonly<NumericArray>, order: EulerRotationOrder = 'zyx'): this {
+  fromRotationMatrix(m: Readonly<NumericArray>, order: EulerRotationOrder = this.order): this {
     this._fromRotationMatrix(m, order);
     return this.check();
   }
 
   // ACCESSORS
 
-  getRotationMatrix(m: NumericArray): NumericArray {
-    return this._getRotationMatrix(m);
-  }
-
-  // TODO - move to Quaternion
-  getQuaternion(): Quaternion {
-    const q = new Quaternion();
-    switch (this[3]) {
-      case RotationOrderIndex.XYZ:
-        return q.rotateX(this[0]).rotateY(this[1]).rotateZ(this[2]);
-      case RotationOrderIndex.YXZ:
-        return q.rotateY(this[1]).rotateX(this[0]).rotateZ(this[2]);
-      case RotationOrderIndex.ZXY:
-        return q.rotateZ(this[2]).rotateX(this[0]).rotateY(this[1]);
-      case RotationOrderIndex.ZYX:
-        return q.rotateZ(this[2]).rotateY(this[1]).rotateX(this[0]);
-      case RotationOrderIndex.YZX:
-        return q.rotateY(this[1]).rotateZ(this[2]).rotateX(this[0]);
-      case RotationOrderIndex.XZY:
-        return q.rotateX(this[0]).rotateZ(this[2]).rotateY(this[1]);
-      default:
-        throw new Error(ERR_UNKNOWN_ORDER);
-    }
+  getRotationMatrix(
+    result: NumericArray = [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0]
+  ): NumericArray {
+    return this._getRotationMatrix(result);
   }
 
   // INTERNAL METHODS
@@ -347,7 +267,7 @@ export class Euler extends MathArray {
   //   const q = new Quaternion().setFromEuler(this);
   //   return this.setFromQuaternion(q, newOrder);
   /* eslint-disable complexity, max-statements, one-var */
-  _fromRotationMatrix(m: Readonly<NumericArray>, order: EulerRotationOrder = 'zyx'): this {
+  _fromRotationMatrix(m: Readonly<NumericArray>, order: EulerRotationOrder = this.order): this {
     // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
     const m11 = m[0],
       m12 = m[4],
@@ -549,21 +469,6 @@ export class Euler extends MathArray {
     te[15] = 1;
     return te;
   }
-
-  toQuaternion(): Quaternion {
-    // Abbreviations for the various angular functions
-    const cy = Math.cos(this.yaw * 0.5);
-    const sy = Math.sin(this.yaw * 0.5);
-    const cr = Math.cos(this.roll * 0.5);
-    const sr = Math.sin(this.roll * 0.5);
-    const cp = Math.cos(this.pitch * 0.5);
-    const sp = Math.sin(this.pitch * 0.5);
-    const w = cy * cr * cp + sy * sr * sp;
-    const x = cy * sr * cp - sy * cr * sp;
-    const y = cy * cr * sp + sy * sr * cp;
-    const z = sy * cr * cp - cy * sr * sp;
-    return new Quaternion(x, y, z, w);
-  }
 }
 
 // HELPER FUNCTIONS

package/src/classes/matrix3.ts

@@ -65,17 +65,11 @@ export class Matrix3 extends Matrix {
     return INDICES;
   }
 
-  constructor(array?: Readonly<NumericArray>);
-  /** @deprecated */
-  constructor(...args: number[]);
-
-  constructor(array?: number | Readonly<NumericArray>, ...args: number[]) {
+  constructor(array?: Readonly<NumericArray>) {
     // PERF NOTE: initialize elements as double precision numbers
     super(-0, -0, -0, -0, -0, -0, -0, -0, -0);
     if (arguments.length === 1 && Array.isArray(array)) {
       this.copy(array);
-    } else if (args.length > 0) {
-      this.copy([array as number, ...args]);
     } else {
       this.identity();
     }
@@ -119,6 +113,21 @@ export class Matrix3 extends Matrix {
     return this.check();
   }
 
+  /** Sets this matrix from the upper-left 3x3 elements of a 4x4 matrix. */
+  fromMatrix4(matrix4: Readonly<NumericArray>): this {
+    return this.set(
+      matrix4[0],
+      matrix4[1],
+      matrix4[2],
+      matrix4[4],
+      matrix4[5],
+      matrix4[6],
+      matrix4[8],
+      matrix4[9],
+      matrix4[10]
+    );
+  }
+
   /**
    * accepts column major order, stores in column major order
    */
@@ -240,21 +249,6 @@ export class Matrix3 extends Matrix {
     checkVector(out, vector.length);
     return out;
   }
-
-  /** @deprecated */
-  transformVector(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray {
-    return this.transform(vector, result);
-  }
-
-  /** @deprecated */
-  transformVector2(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray {
-    return this.transform(vector, result);
-  }
-
-  /** @deprecated */
-  transformVector3(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray {
-    return this.transform(vector, result);
-  }
 }
 
 let ZERO_MATRIX3: Matrix3 | null;

package/src/classes/matrix4.ts

@@ -5,6 +5,7 @@
 
 import {NumericArray, NumericArray16} from '@math.gl/types';
 import {Matrix} from './base/matrix';
+import type {Matrix3Like} from './matrix3';
 import {checkVector} from '../lib/validators';
 
 /* eslint-disable camelcase */
@@ -240,6 +241,32 @@ export class Matrix4 extends Matrix {
     return this.check();
   }
 
+  /**
+   * Sets this matrix from a 3x3 matrix, with zero translation.
+   * @param matrix3 - 3x3 matrix in column-major order.
+   * @returns This matrix.
+   */
+  fromMatrix3(matrix3: Readonly<Matrix3Like>): this {
+    return this.set(
+      matrix3[0],
+      matrix3[1],
+      matrix3[2],
+      0,
+      matrix3[3],
+      matrix3[4],
+      matrix3[5],
+      0,
+      matrix3[6],
+      matrix3[7],
+      matrix3[8],
+      0,
+      0,
+      0,
+      0,
+      1
+    );
+  }
+
   /**
    * Generates a frustum matrix with the given bounds
    * @param view.left - Left bound of the frustum
@@ -608,21 +635,6 @@ export class Matrix4 extends Matrix {
     return out;
   }
 
-  /** @deprecated */
-  transformPoint(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray {
-    return this.transformAsPoint(vector, result);
-  }
-
-  /** @deprecated */
-  transformVector(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray {
-    return this.transformAsPoint(vector, result);
-  }
-
-  /** @deprecated */
-  transformDirection(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray {
-    return this.transformAsVector(vector, result);
-  }
-
   // three.js math API compatibility
 
   makeRotationX(radians: number): this {

package/src/classes/quaternion.ts

@@ -5,8 +5,8 @@
 
 import {NumericArray} from '@math.gl/types';
 import {MathArray} from './base/math-array';
-import {checkNumber, checkVector} from '../lib/validators';
-import {Vector4} from './vector4';
+import {checkNumber} from '../lib/validators';
+import type {EulerLike} from './euler-types';
 // @ts-ignore gl-matrix types...
 import {
   fromMat3 as quat_fromMat3,
@@ -29,11 +29,6 @@ import {
   scale as quat_scale,
   slerp as quat_slerp
 } from '../gl-matrix/quat';
-// @ts-ignore gl-matrix types...
-import {transformQuat as vec4_transformQuat} from '../gl-matrix/vec4';
-
-const IDENTITY_QUATERNION = [0, 0, 0, 1] as const;
-
 export class Quaternion extends MathArray {
   constructor(x: number | Readonly<NumericArray> = 0, y = 0, z = 0, w = 1) {
     // PERF NOTE: initialize elements as double precision numbers
@@ -82,6 +77,31 @@ export class Quaternion extends MathArray {
     return this.check();
   }
 
+  /**
+   * Sets this quaternion from Euler angles.
+   * @param euler - Euler angles and rotation order.
+   * @returns This quaternion.
+   */
+  fromEuler(euler: Readonly<EulerLike>): this {
+    this.identity();
+    switch (euler.order) {
+      case 'xyz':
+        return this.rotateX(euler.x).rotateY(euler.y).rotateZ(euler.z);
+      case 'yxz':
+        return this.rotateY(euler.y).rotateX(euler.x).rotateZ(euler.z);
+      case 'zxy':
+        return this.rotateZ(euler.z).rotateX(euler.x).rotateY(euler.y);
+      case 'zyx':
+        return this.rotateZ(euler.z).rotateY(euler.y).rotateX(euler.x);
+      case 'yzx':
+        return this.rotateY(euler.y).rotateZ(euler.z).rotateX(euler.x);
+      case 'xzy':
+        return this.rotateX(euler.x).rotateZ(euler.z).rotateY(euler.y);
+      default:
+        throw new Error('Unknown Euler angle order');
+    }
+  }
+
   fromAxisRotation(axis: Readonly<NumericArray>, rad: number): this {
     quat_setAxisAngle(this, axis, rad);
     return this.check();
@@ -272,41 +292,13 @@ export class Quaternion extends MathArray {
 
   slerp(target: Readonly<NumericArray>, ratio: number): this;
   slerp(start: Readonly<NumericArray>, target: Readonly<NumericArray>, ratio: number): this;
-  slerp(params: {
-    start: Readonly<NumericArray>;
-    target: Readonly<NumericArray>;
-    ratio: number;
-  }): this;
-
   // Performs a spherical linear interpolation between two quat
-  slerp(
-    arg0:
-      | Readonly<NumericArray>
-      | {
-          start: Readonly<NumericArray>;
-          target: Readonly<NumericArray>;
-          ratio: number;
-        },
-    arg1?: Readonly<NumericArray> | number,
-    arg2?: number
-  ): this {
+  slerp(arg0: Readonly<NumericArray>, arg1?: Readonly<NumericArray> | number, arg2?: number): this {
     let start: Readonly<NumericArray>;
     let target: Readonly<NumericArray>;
     let ratio: number;
     // eslint-disable-next-line prefer-rest-params
     switch (arguments.length) {
-      case 1: // Deprecated signature ({start, target, ratio})
-        // eslint-disable-next-line prefer-rest-params
-        ({
-          start = IDENTITY_QUATERNION,
-          target,
-          ratio
-        } = arg0 as {
-          start: Readonly<NumericArray>;
-          target: Readonly<NumericArray>;
-          ratio: number;
-        });
-        break;
       case 2: // THREE.js compatibility signature (target, ration)
         start = this; // eslint-disable-line
         target = arg0 as Readonly<NumericArray>;
@@ -322,14 +314,6 @@ export class Quaternion extends MathArray {
     return this.check();
   }
 
-  transformVector4(
-    vector: Readonly<NumericArray>,
-    result: NumericArray = new Vector4()
-  ): NumericArray {
-    vec4_transformQuat(result, vector, this);
-    return checkVector(result, 4);
-  }
-
   // THREE.js Math API compatibility
   lengthSq(): number {
     return this.lengthSquared();

package/src/classes/spherical-coordinates.ts

@@ -4,11 +4,8 @@
 // Copyright (c) 2017 Uber Technologies, Inc.
 
 // Adaptation of THREE.js Spherical class, under MIT license
-import {NumericArray} from '@math.gl/types';
-import {Vector3} from './vector3';
+import type {Vector3Like} from './vector3';
 import {formatValue, equals, config, degrees, radians, clamp} from '../lib/common';
-// @ts-ignore gl-matrix types...
-import * as vec3 from '../gl-matrix/vec3';
 
 type SphericalCoordinatesOptions = {
   phi?: number;
@@ -174,8 +171,8 @@ export class SphericalCoordinates {
     return this.check();
   }
 
-  fromVector3(v: Readonly<NumericArray>): this {
-    this.radius = vec3.length(v);
+  fromVector3(v: Readonly<Vector3Like>): this {
+    this.radius = Math.hypot(v[0], v[1], v[2]);
     if (this.radius > 0) {
       this.theta = Math.atan2(v[0], v[1]); // equator angle around y-up axis
       this.phi = Math.acos(clamp(v[2] / this.radius, -1, 1)); // polar angle
@@ -183,10 +180,15 @@ export class SphericalCoordinates {
     return this.check();
   }
 
-  toVector3(): Vector3 {
-    return new Vector3(0, 0, this.radius)
-      .rotateX({radians: this.theta})
-      .rotateZ({radians: this.phi});
+  toVector3(result: Vector3Like = [-0, -0, -0]): Vector3Like {
+    const sinTheta = Math.sin(this.theta);
+    const cosTheta = Math.cos(this.theta);
+    const sinPhi = Math.sin(this.phi);
+    const cosPhi = Math.cos(this.phi);
+    result[0] = this.radius * sinTheta * sinPhi;
+    result[1] = -this.radius * sinTheta * cosPhi;
+    result[2] = this.radius * cosTheta;
+    return result;
   }
 
   // restrict phi to be betwee EPS and PI-EPS

package/src/gl-matrix/quat.ts

@@ -705,7 +705,7 @@ export function equals(a, b) {
  * @param {ReadonlyVec3} b the destination vector
  * @returns {quat} out
  */
-export const rotationTo = (function () {
+export const rotationTo = /* @__PURE__ */ (function () {
   const tmpvec3 = vec3.create();
   const xUnitVec3 = vec3.fromValues(1, 0, 0);
   const yUnitVec3 = vec3.fromValues(0, 1, 0);
@@ -745,7 +745,7 @@ export const rotationTo = (function () {
  * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
  * @returns {quat} out
  */
-export const sqlerp = (function () {
+export const sqlerp = /* @__PURE__ */ (function () {
   const temp1 = create();
   const temp2 = create();
 
@@ -768,7 +768,7 @@ export const sqlerp = (function () {
  * @param {ReadonlyVec3} up    the vector representing the local "up" direction
  * @returns {quat} out
  */
-export const setAxes = (function () {
+export const setAxes = /* @__PURE__ */ (function () {
   const matr = mat3.create();
 
   return function (out, view, right, up) {

package/src/gl-matrix/vec2.ts

@@ -597,7 +597,7 @@ export const sqrLen = squaredLength;
  * @returns {Array} a
  * @function
  */
-export const forEach = (function () {
+export const forEach = /* @__PURE__ */ (function () {
   const vec = create();
 
   return function (a, stride, offset, count, fn, arg) {

package/src/gl-matrix/vec3.ts

@@ -792,7 +792,7 @@ export const sqrLen = squaredLength;
  * @returns {Array} a
  * @function
  */
-export const forEach = (function () {
+export const forEach = /* @__PURE__ */ (function () {
   const vec = create();
 
   return function (a, stride, offset, count, fn, arg) {

package/src/gl-matrix/vec4.ts

@@ -638,7 +638,7 @@ export const sqrLen = squaredLength;
  * @returns {Array} a
  * @function
  */
-export const forEach = (function () {
+export const forEach = /* @__PURE__ */ (function () {
   const vec = create();
 
   return function (a, stride, offset, count, fn, arg) {

package/src/index.ts

@@ -41,7 +41,7 @@ export type {Matrix4Like} from './classes/matrix4';
 export {SphericalCoordinates} from './classes/spherical-coordinates';
 export {Pose} from './classes/pose';
 export {Euler} from './classes/euler';
-export type {EulerRotationOrder} from './classes/euler';
+export type {EulerLike, EulerRotationOrder} from './classes/euler-types';
 
 export * as _MathUtils from './lib/math-utils';
 
@@ -64,31 +64,7 @@ export {
   // math.gl "GLSL"-style functions
   radians,
   degrees,
-  sin,
-  cos,
-  tan,
-  asin,
-  acos,
-  atan,
   clamp,
   lerp,
   withEpsilon
 } from './lib/common';
-
-// DEPRECATED
-export {SphericalCoordinates as _SphericalCoordinates} from './classes/spherical-coordinates';
-export {Pose as _Pose} from './classes/pose';
-export {Euler as _Euler} from './classes/euler';
-
-/** @deprecated Use Matrix3 */
-export * as mat3 from './gl-matrix/mat3';
-/** @deprecated Use Matrix4 */
-export * as mat4 from './gl-matrix/mat4';
-/** @deprecated Use Quaterinion */
-export * as quat from './gl-matrix/quat';
-/** @deprecated UseVector */
-export * as vec2 from './gl-matrix/vec2';
-/** @deprecated Use Vector3 */
-export * as vec3 from './gl-matrix/vec3';
-/** @deprecated Use Vector4 */
-export * as vec4 from './gl-matrix/vec4';

package/src/lib/common.ts

@@ -189,54 +189,6 @@ function negativePiToPi(angle: number): number {
   return zeroToTwoPi(angle + PI) - PI;
 }
 
-/**
- * "GLSL equivalent" of `Math.sin`: Works on single values and vectors
- * @deprecated
- */
-export function sin(radians: number | NumericArray, result?: NumericArray): number | NumericArray {
-  return map(radians, angle => Math.sin(angle), result);
-}
-
-/**
- * "GLSL equivalent" of `Math.cos`: Works on single values and vectors
- * @deprecated
- */
-export function cos(radians: number | NumericArray, result?: NumericArray): number | NumericArray {
-  return map(radians, angle => Math.cos(angle), result);
-}
-
-/**
- * "GLSL equivalent" of `Math.tan`: Works on single values and vectors
- * @deprecated
- */
-export function tan(radians: number | NumericArray, result?: NumericArray): number | NumericArray {
-  return map(radians, angle => Math.tan(angle), result);
-}
-
-/**
- * "GLSL equivalent" of `Math.asin`: Works on single values and vectors
- * @deprecated
- */
-export function asin(radians: number | NumericArray, result?: NumericArray): number | NumericArray {
-  return map(radians, angle => Math.asin(angle), result);
-}
-
-/**
- * "GLSL equivalent" of `Math.acos`: Works on single values and vectors
- * @deprecated
- */
-export function acos(radians: number | NumericArray, result?: NumericArray): number | NumericArray {
-  return map(radians, angle => Math.acos(angle), result);
-}
-
-/**
- * "GLSL equivalent" of `Math.atan`: Works on single values and vectors
- * @deprecated
- */
-export function atan(radians: number | NumericArray, result?: NumericArray): number | NumericArray {
-  return map(radians, angle => Math.atan(angle), result);
-}
-
 /**
  * GLSL style value clamping: Works on single values and vectors
  */

package/src/lib/validators.ts

@@ -35,15 +35,3 @@ export function checkVector<T extends NumericArray>(
   }
   return v;
 }
-
-const map: Record<string, boolean> = {};
-
-export function deprecated(method: string, version: string): void {
-  if (!map[method]) {
-    map[method] = true;
-    // biome-ignore lint/suspicious/noConsole: deprecations are intentionally reported to users.
-    console.warn(
-      `${method} has been removed in version ${version}, see upgrade guide for more information`
-    );
-  }
-}

package/src/mat3.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export * from './gl-matrix/mat3';

package/src/mat4.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export * from './gl-matrix/mat4';

package/src/quat.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export * from './gl-matrix/quat';

package/src/vec2.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export * from './gl-matrix/vec2';

package/src/vec3.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export * from './gl-matrix/vec3';

package/src/vec4.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export * from './gl-matrix/vec4';