@jscad/modeling 2.12.5 → 3.0.1-alpha.0

package/src/maths/plane/transform.js

@@ -1,20 +1,20 @@
-const mat4 = require('../mat4')
-const vec3 = require('../vec3')
+import * as mat4 from '../mat4/index.js'
+import * as vec3 from '../vec3/index.js'
 
-const fromPoints = require('./fromPoints')
-const flip = require('./flip')
+import { fromPoints } from './fromPoints.js'
+import { flip } from './flip.js'
 
 /**
  * Transform the given plane using the given matrix
  *
- * @param {plane} out - receiving plane
- * @param {plane} plane - plane to transform
- * @param {mat4} matrix - matrix to transform with
- * @return {plane} out
+ * @param {Plane} out - receiving plane
+ * @param {Plane} plane - plane to transform
+ * @param {Mat4} matrix - matrix to transform with
+ * @return {Plane} out
  * @alias module:modeling/maths/plane.transform
  */
-const transform = (out, plane, matrix) => {
-  const ismirror = mat4.isMirroring(matrix)
+export const transform = (out, plane, matrix) => {
+  const isMirror = mat4.isMirroring(matrix)
   // get two vectors in the plane:
   const r = vec3.orthogonal(vec3.create(), plane)
   const u = vec3.cross(r, plane, r)
@@ -30,11 +30,9 @@ const transform = (out, plane, matrix) => {
   point3 = vec3.transform(point3, point3, matrix)
   // and create a new plane from the transformed points:
   fromPoints(out, point1, point2, point3)
-  if (ismirror) {
+  if (isMirror) {
     // the transform is mirroring so flip the plane
     flip(out, out)
   }
   return out
 }
-
-module.exports = transform

package/src/maths/plane/transform.test.js

@@ -1,7 +1,8 @@
-const test = require('ava')
-const { transform, create, fromValues } = require('./index')
+import test from 'ava'
 
-const { compareVectors } = require('../../../test/helpers/index')
+import { transform, create, fromValues } from './index.js'
+
+import { compareVectors } from '../../../test/helpers/index.js'
 
 test('plane: transform() called with three parameters should return a plane with correct values', (t) => {
   const identityMatrix = [

package/src/maths/plane/type.d.ts

@@ -1,3 +1 @@
-export default Plane
-
-declare type Plane = [number, number, number, number]
+export type Plane = [number, number, number, number]

package/src/maths/rotation.test.js

@@ -1,8 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const { compareVectors } = require('../../test/helpers/index')
+import { compareVectors } from '../../test/helpers/index.js'
 
-const { constants, mat4, vec2, vec3 } = require('./index')
+import { TAU, mat4, vec2, vec3 } from './index.js'
 
 // ALL POSITIVE ROTATIONS ARE CLOCKWISE
 // see https://webglfundamentals.org/webgl/lessons/webgl-3d-orthographic.html
@@ -13,7 +13,7 @@ const { constants, mat4, vec2, vec3 } = require('./index')
 
 // identity matrices for comparisons
 
-const rad90 = constants.TAU / 4
+const rad90 = TAU / 4
 
 // +90 degree rotation about X
 const cwX90Matrix = [

package/src/maths/types.d.ts

@@ -1,8 +1,15 @@
-export { default as Line2 } from './line2/type'
-export { default as Line3 } from './line3/type'
-export { default as Mat4 } from './mat4/type'
-export { default as Plane } from './plane/type'
-export { default as Vec1 } from './vec1/type'
-export { default as Vec2 } from './vec2/type'
-export { default as Vec3 } from './vec3/type'
-export { default as Vec4 } from './vec4/type'
+import type { Vec1 } from './vec1/type.d.ts'
+import type { Vec2 } from './vec2/type.d.ts'
+import type { Vec3 } from './vec3/type.d.ts'
+import type { Vec4 } from './vec4/type.d.ts'
+
+export type { Line2 } from './line2/type.d.ts'
+export type { Line3 } from './line3/type.d.ts'
+export type { Mat4 } from './mat4/type.d.ts'
+export type { Plane } from './plane/type.d.ts'
+export type { Vec1 } from './vec1/type.d.ts'
+export type { Vec2 } from './vec2/type.d.ts'
+export type { Vec3 } from './vec3/type.d.ts'
+export type { Vec4 } from './vec4/type.d.ts'
+
+export type Vec = Vec1 | Vec2 | Vec3 | Vec4

package/src/maths/utils/OrthonormalFormula.d.ts

@@ -0,0 +1,9 @@
+import type { Plane } from '../plane/type.d.ts'
+import type { Vec2 } from '../vec2/type.d.ts'
+import type { Vec3 } from '../vec3/type.d.ts'
+
+export class OrthonormalFormula {
+  constructor (plane: Plane)
+  to2D (vertex: Vec3): Vec2
+  to3D (point: Vec2): Vec3
+}

package/src/maths/utils/OrthonormalFormula.js

@@ -0,0 +1,82 @@
+import * as mat4 from '../mat4/index.js'
+
+import * as vec2 from '../vec2/index.js'
+import * as vec3 from '../vec3/index.js'
+
+/*
+ * Class that defines the formula for convertion to/from orthonomal basis vectors.
+ * @see https://www.kristakingmath.com/blog/orthonormal-basis-for-a-vector-set
+ */
+export class OrthonormalFormula {
+  /**
+   * Construct the standard basis formula from the given plane.
+   * @param {Plane} plane - the plane of which to convert vertices to/from the orthonormal basis
+   */
+  constructor (plane) {
+    // plane normal is one component
+    this.plane = plane
+    // orthogonal vector to plane normal is one component
+    const rightVector = vec3.orthogonal(vec3.create(), plane)
+    this.v = vec3.normalize(rightVector, vec3.cross(rightVector, plane, rightVector))
+    // cross between plane normal and orthogonal vector is one component
+    this.u = vec3.cross(vec3.create(), this.v, plane)
+
+    this.planeOrigin = vec3.scale(vec3.create(), plane, plane[3])
+    this.basisMap = new Map()
+  }
+
+  /**
+   * Convert the basis formula to a projection matrix.
+   * @return {Mat4} matrix which can be used to convert 3D vertices to 2D points
+   */
+  getProjectionMatrix () {
+    return mat4.fromValues(
+      this.u[0], this.v[0], this.plane[0], 0,
+      this.u[1], this.v[1], this.plane[1], 0,
+      this.u[2], this.v[2], this.plane[2], 0,
+      0, 0, -this.plane[3], 1
+    )
+  }
+
+  /**
+   * Convert the basis formula to an inverse projection matrix.
+   * @return {Mat4} matrix which can be used to convert 2D points to 3D vertices
+   */
+  getInverseProjectionMatrix () {
+    return mat4.fromValues(
+      this.u[0], this.u[1], this.u[2], 0,
+      this.v[0], this.v[1], this.v[2], 0,
+      this.plane[0], this.plane[1], this.plane[2], 0,
+      this.planeOrigin[0], this.planeOrigin[1], this.planeOrigin[2], 1
+    )
+  }
+
+  /**
+   * Convert the given 3D vertex to a 2D point which exists in the orthonormal basis
+   * @param {Vec3} vertex - 3D vertex which lies within the original basis (set)
+   * @return {Vec2} - 2D point which lies within the orthonormal basis
+   */
+  to2D (vertex) {
+    const point = vec2.fromValues(vec3.dot(vertex, this.u), vec3.dot(vertex, this.v))
+    this.basisMap.set(point, vertex)
+    return point
+  }
+
+  /**
+   * Convert the given 2D point to a 3D vertex which exists in the original basis (set)
+   * @param {Vec2} point - 2D point which lies within the orthonormal basis
+   * @return {Vec3} - 3D vertex which lies within the original basis (set)
+   */
+  to3D (point) {
+    // return the original vertex if possible, i.e. no floating point error
+    const original = this.basisMap.get(point)
+    if (original) return original
+
+    // calculate a new 3D vertex from the orthonormal basis formula
+    const v1 = vec3.scale(vec3.create(), this.u, point[0])
+    const v2 = vec3.scale(vec3.create(), this.v, point[1])
+    const v3 = vec3.add(v1, v1, this.planeOrigin)
+    const v4 = vec3.add(v2, v2, v3)
+    return v4
+  }
+}

package/src/maths/utils/OrthonormalFormula.test.js

@@ -0,0 +1,72 @@
+import test from 'ava'
+
+import * as vec3 from '../vec3/index.js'
+import { plane } from '../index.js'
+
+import { OrthonormalFormula } from './OrthonormalFormula.js'
+
+test('utils: OrthonormalFormula constructor', (t) => {
+  const p1 = plane.fromNormalAndPoint(plane.create(), [5, 0, 0], [0, 0, 0])
+  const p2 = plane.fromNormalAndPoint(plane.create(), [0, 0, 5], [5, 5, 5])
+
+  const o1 = new OrthonormalFormula(p1)
+  t.deepEqual(o1.u, [0, -1, 0])
+  t.deepEqual(o1.v, [0, 0, -1])
+
+  const o2 = new OrthonormalFormula(p2)
+  t.deepEqual(o2.u, [-1, 0, 0])
+  t.deepEqual(o2.v, [0, -1, 0])
+})
+
+test('utils: OrthonormalFormula methods', (t) => {
+  const p1 = plane.fromNormalAndPoint(plane.create(), [5, 0, 0], [5, 0, 0])
+  const o1 = new OrthonormalFormula(p1)
+
+  const v1 = vec3.fromValues(5, 0, 0)
+  const v2 = vec3.fromValues(0, 5, 0)
+  const v3 = vec3.fromValues(0, 0, 5)
+  const v4 = vec3.fromValues(-5, 0, 0)
+  const v5 = vec3.fromValues(0, -5, 0)
+  const v6 = vec3.fromValues(0, 0, -5)
+
+  const t1 = o1.to2D(v1)
+  t.deepEqual(t1, [0, 0])
+  const t2 = o1.to2D(v2)
+  t.deepEqual(t2, [-5, 0])
+  const t3 = o1.to2D(v3)
+  t.deepEqual(t3, [0, -5])
+  const t4 = o1.to2D(v4)
+  t.deepEqual(t4, [0, 0])
+  const t5 = o1.to2D(v5)
+  t.deepEqual(t5, [5, 0])
+  const t6 = o1.to2D(v6)
+  t.deepEqual(t3, [0, -5])
+
+  const r1 = o1.to3D(t1)
+  t.deepEqual(r1, v1)
+  const r2 = o1.to3D(t2)
+  t.deepEqual(r2, v2)
+  const r3 = o1.to3D(t3)
+  t.deepEqual(r3, v3)
+  const r4 = o1.to3D(t4)
+  t.deepEqual(r4, v4)
+  const r5 = o1.to3D(t5)
+  t.deepEqual(r5, v5)
+  const r6 = o1.to3D(t6)
+  t.deepEqual(r6, v6)
+
+  const m1 = o1.getProjectionMatrix()
+  t.deepEqual(m1, [
+    0, 0, 1, 0,
+    -1, 0, 0, 0,
+    0, -1, 0, 0,
+    0, 0, -5, 1
+  ])
+  const m2 = o1.getInverseProjectionMatrix()
+  t.deepEqual(m2, [
+    0, -1, 0, 0,
+    0, 0, -1, 0,
+    1, 0, 0, 0,
+    5, 0, 0, 1
+  ])
+})

package/src/maths/utils/aboutEqualNormals.d.ts

@@ -1,5 +1,3 @@
-import Vec3 from '../vec3/type'
+import type { Vec3 } from '../vec3/type.d.ts'
 
-export default aboutEqualNormals
-
-declare function aboutEqualNormals(a: Vec3, b: Vec3): boolean
+export function aboutEqualNormals(a: Vec3, b: Vec3): boolean

package/src/maths/utils/aboutEqualNormals.js

@@ -1,12 +1,10 @@
-const { NEPS } = require('../constants')
+import { NEPS } from '../constants.js'
 
 /**
  * Compare two normals (unit vectors) for near equality.
- * @param {vec3} a - normal a
- * @param {vec3} b - normal b
+ * @param {Vec3} a - normal a
+ * @param {Vec3} b - normal b
  * @returns {Boolean} true if a and b are nearly equal
  * @alias module:modeling/maths/utils.aboutEqualNormals
  */
-const aboutEqualNormals = (a, b) => (Math.abs(a[0] - b[0]) <= NEPS && Math.abs(a[1] - b[1]) <= NEPS && Math.abs(a[2] - b[2]) <= NEPS)
-
-module.exports = aboutEqualNormals
+export const aboutEqualNormals = (a, b) => (Math.abs(a[0] - b[0]) <= NEPS && Math.abs(a[1] - b[1]) <= NEPS && Math.abs(a[2] - b[2]) <= NEPS)

package/src/maths/utils/area.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from '../vec2/type'
+import type { Vec2 } from '../vec2/type.d.ts'
 
-export default area
-
-declare function area(points: Array<Vec2>): number
+export function area(points: Array<Vec2>): number

package/src/maths/utils/area.js

@@ -1,10 +1,10 @@
 /**
  * Calculate the area under the given points.
  * @param {Array} points - list of 2D points
- * @return {Number} area under the given points
+ * @return {number} area under the given points
  * @alias module:modeling/maths/utils.area
  */
-const area = (points) => {
+export const area = (points) => {
   let area = 0
   for (let i = 0; i < points.length; i++) {
     const j = (i + 1) % points.length
@@ -13,5 +13,3 @@ const area = (points) => {
   }
   return (area / 2.0)
 }
-
-module.exports = area

package/src/maths/utils/interpolateBetween2DPointsForY.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from '../vec2/type'
+import type { Vec2 } from '../vec2/type.d.ts'
 
-export default interpolateBetween2DPointsForY
-
-declare function interpolateBetween2DPointsForY(point1: Vec2, point2: Vec2, y: number): number
+export function interpolateBetween2DPointsForY(point1: Vec2, point2: Vec2, y: number): number

package/src/maths/utils/interpolateBetween2DPointsForY.js

@@ -1,13 +1,13 @@
 /**
  * Get the X coordinate of a point with a certain Y coordinate, interpolated between two points.
  * Interpolation is robust even if the points have the same Y coordinate
- * @param {vec2} point1
- * @param {vec2} point2
- * @param {Number} y
+ * @param {Vec2} point1
+ * @param {Vec2} point2
+ * @param {number} y
  * @return {Array} X and Y of interpolated point
  * @alias module:modeling/maths/utils.interpolateBetween2DPointsForY
  */
-const interpolateBetween2DPointsForY = (point1, point2, y) => {
+export const interpolateBetween2DPointsForY = (point1, point2, y) => {
   let f1 = y - point1[1]
   let f2 = point2[1] - point1[1]
   if (f2 < 0) {
@@ -27,5 +27,3 @@ const interpolateBetween2DPointsForY = (point1, point2, y) => {
   const result = point1[0] + t * (point2[0] - point1[0])
   return result
 }
-
-module.exports = interpolateBetween2DPointsForY

package/src/maths/utils/intersect.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from '../vec2/type'
+import type { Vec2 } from '../vec2/type.d.ts'
 
-export default intersect
-
-declare function intersect(p1: Vec2, p2: Vec2, p3: Vec2, p4: Vec2): Vec2
+export function intersect(p1: Vec2, p2: Vec2, p3: Vec2, p4: Vec2, endpointTouch?: boolean): Vec2

package/src/maths/utils/intersect.js

@@ -1,15 +1,17 @@
 /**
- * Calculate the intersect point of the two line segments (p1-p2 and p3-p4), end points included.
+ * Calculate the intersect point of the two line segments (p1-p2 and p3-p4).
+ * If the endpointTouch parameter is false, intersections at segment end points are excluded.
  * Note: If the line segments do NOT intersect then undefined is returned.
  * @see http://paulbourke.net/geometry/pointlineplane/
- * @param {vec2} p1 - first point of first line segment
- * @param {vec2} p2 - second point of first line segment
- * @param {vec2} p3 - first point of second line segment
- * @param {vec2} p4 - second point of second line segment
- * @returns {vec2} intersection point of the two line segments, or undefined
+ * @param {Vec2} p1 - first point of first line segment
+ * @param {Vec2} p2 - second point of first line segment
+ * @param {Vec2} p3 - first point of second line segment
+ * @param {Vec2} p4 - second point of second line segment
+ * @param {boolean} endpointTouch - include intersections at segment endpoints
+ * @returns {Vec2} intersection point of the two line segments, or undefined
  * @alias module:modeling/maths/utils.intersect
  */
-const intersect = (p1, p2, p3, p4) => {
+export const intersect = (p1, p2, p3, p4, endpointTouch = true) => {
   // Check if none of the lines are of length 0
   if ((p1[0] === p2[0] && p1[1] === p2[1]) || (p3[0] === p4[0] && p3[1] === p4[1])) {
     return undefined
@@ -30,11 +32,14 @@ const intersect = (p1, p2, p3, p4) => {
     return undefined
   }
 
+  // is the intersection at the end of a segment
+  if (!endpointTouch && (ua === 0 || ua === 1 || ub === 0 || ub === 1)) {
+    return undefined
+  }
+
   // Return the x and y coordinates of the intersection
   const x = p1[0] + ua * (p2[0] - p1[0])
   const y = p1[1] + ua * (p2[1] - p1[1])
 
   return [x, y]
 }
-
-module.exports = intersect

package/src/maths/utils/intersect.test.js

@@ -0,0 +1,40 @@
+import test from 'ava'
+
+import * as vec2 from '../vec2/index.js'
+import { intersect } from './intersect.js'
+
+//   A     __F
+//  / \ __E
+// B   D   \
+//  \ /     \
+//   C       G
+
+const a = vec2.fromValues(0, 1)
+const b = vec2.fromValues(-1, 0)
+const c = vec2.fromValues(0, -1)
+const d = vec2.fromValues(1, 0)
+const e = vec2.fromValues(2, 0.5)
+const f = vec2.fromValues(3, 1)
+const g = vec2.fromValues(2, -1)
+
+test('utils: intersect() for intersecting lines', (t) => {
+  t.deepEqual(intersect(a, c, b, d), [0, 0])
+  t.deepEqual(intersect(a, b, b, c), b)
+  t.deepEqual(intersect(d, f, e, g), e)
+})
+
+test('utils: intersect() for non-intersecting lines', (t) => {
+  t.is(intersect(a, a, b, c), undefined)
+  t.is(intersect(a, d, b, c), undefined)
+  t.is(intersect(a, b, d, e), undefined)
+})
+
+test('utils: intersect() endpointTouch parameter', (t) => {
+  // endpoint touching
+  t.deepEqual(intersect(a, b, b, c), b)
+  t.deepEqual(intersect(a, b, b, c, true), b)
+  t.deepEqual(intersect(a, b, b, c, false), undefined)
+  t.deepEqual(intersect(d, f, e, g), e)
+  t.deepEqual(intersect(d, f, e, g, true), e)
+  t.deepEqual(intersect(d, f, e, g, false), undefined)
+})

package/src/maths/utils/solve2Linear.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from '../vec2/type'
+import type { Vec2 } from '../vec2/type.d.ts'
 
-export default solve2Linear
-
-declare function solve2Linear(a: number, b: number, c: number, d: number, u: number, v: number): Vec2
+export function solve2Linear(a: number, b: number, c: number, d: number, u: number, v: number): Vec2

package/src/maths/utils/solve2Linear.js

@@ -1,4 +1,4 @@
-const solve2Linear = (a, b, c, d, u, v) => {
+export const solve2Linear = (a, b, c, d, u, v) => {
   const det = a * d - b * c
   const invdet = 1.0 / det
   let x = u * d - b * v
@@ -7,5 +7,3 @@ const solve2Linear = (a, b, c, d, u, v) => {
   y *= invdet
   return [x, y]
 }
-
-module.exports = solve2Linear

package/src/maths/utils/trigonometry.js

@@ -1,4 +1,4 @@
-const { NEPS } = require('../constants')
+import { NEPS } from '../constants.js'
 
 /*
  * Returns zero if n is within epsilon of zero, otherwise return n
@@ -9,26 +9,24 @@ const rezero = (n) => Math.abs(n) < NEPS ? 0 : n
  * Return Math.sin but accurate for TAU / 4 rotations.
  * Fixes rounding errors when sin should be 0.
  *
- * @param {Number} radians - angle in radians
- * @returns {Number} sine of the given angle
+ * @param {number} radians - angle in radians
+ * @returns {number} sine of the given angle
  * @alias module:modeling/utils.sin
  * @example
  * sin(TAU / 2) == 0
  * sin(TAU) == 0
  */
-const sin = (radians) => rezero(Math.sin(radians))
+export const sin = (radians) => rezero(Math.sin(radians))
 
 /**
  * Return Math.cos but accurate for TAU / 4 rotations.
  * Fixes rounding errors when cos should be 0.
  *
- * @param {Number} radians - angle in radians
- * @returns {Number} cosine of the given angle
+ * @param {number} radians - angle in radians
+ * @returns {number} cosine of the given angle
  * @alias module:modeling/utils.cos
  * @example
  * cos(TAU * 0.25) == 0
  * cos(TAU * 0.75) == 0
  */
-const cos = (radians) => rezero(Math.cos(radians))
-
-module.exports = { sin, cos }
+export const cos = (radians) => rezero(Math.cos(radians))

package/src/maths/utils/trigonometry.test.js

@@ -1,8 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const { TAU } = require('../constants')
+import { TAU } from '../constants.js'
 
-const { cos, sin } = require('./trigonometry')
+import { cos, sin } from './trigonometry.js'
 
 test('utils: sin() should return rounded values', (t) => {
   t.is(sin(0), 0)

package/src/maths/vec1/type.d.ts

@@ -1,3 +1 @@
-export default Vec1
-
-declare type Vec1 = [number]
+export type Vec1 = [number]

package/src/maths/vec2/abs.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from './type'
+import type { Vec2 } from './type.d.ts'
 
-export default abs
-
-declare function abs(out: Vec2, vector: Vec2): Vec2
+export function abs(out: Vec2, vector: Vec2): Vec2

package/src/maths/vec2/abs.js

@@ -1,15 +1,13 @@
 /**
  * Calculates the absolute coordinates of the given vector.
  *
- * @param {vec2} out - receiving vector
- * @param {vec2} vector - vector of reference
- * @returns {vec2} out
+ * @param {Vec2} out - receiving vector
+ * @param {Vec2} vector - vector of reference
+ * @returns {Vec2} out
  * @alias module:modeling/maths/vec2.abs
  */
-const abs = (out, vector) => {
+export const abs = (out, vector) => {
   out[0] = Math.abs(vector[0])
   out[1] = Math.abs(vector[1])
   return out
 }
-
-module.exports = abs

package/src/maths/vec2/abs.test.js

@@ -1,7 +1,8 @@
-const test = require('ava')
-const { abs, create } = require('./index')
+import test from 'ava'
 
-const { compareVectors } = require('../../../test/helpers/index')
+import { abs, create } from './index.js'
+
+import { compareVectors } from '../../../test/helpers/index.js'
 
 test('vec2: abs() with two params should update a vec2 with correct values', (t) => {
   const vec1 = create()

package/src/maths/vec2/add.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from './type'
+import type { Vec2 } from './type.d.ts'
 
-export default add
-
-declare function add(out: Vec2, a: Vec2, b: Vec2): Vec2
+export function add(out: Vec2, a: Vec2, b: Vec2): Vec2

package/src/maths/vec2/add.js

@@ -1,16 +1,14 @@
 /**
  * Adds the coordinates of two vectors (A+B).
  *
- * @param {vec2} out - receiving vector
- * @param {vec2} a - first operand
- * @param {vec2} b - second operand
- * @returns {vec2} out
+ * @param {Vec2} out - receiving vector
+ * @param {Vec2} a - first operand
+ * @param {Vec2} b - second operand
+ * @returns {Vec2} out
  * @alias module:modeling/maths/vec2.add
  */
-const add = (out, a, b) => {
+export const add = (out, a, b) => {
   out[0] = a[0] + b[0]
   out[1] = a[1] + b[1]
   return out
 }
-
-module.exports = add

package/src/maths/vec2/add.test.js

@@ -1,7 +1,8 @@
-const test = require('ava')
-const { add, fromValues } = require('./index')
+import test from 'ava'
 
-const { compareVectors } = require('../../../test/helpers/index')
+import { add, fromValues } from './index.js'
+
+import { compareVectors } from '../../../test/helpers/index.js'
 
 test('vec2: add() called with three parameters should update a vec2 with correct values', (t) => {
   const obs1 = fromValues(0, 0)

package/src/maths/vec2/angle.d.ts

@@ -1,3 +1 @@
-import angleRadians from './angleRadians'
-
-export default angleRadians
+export { angleRadians as angle } from './angleRadians.js'

package/src/maths/vec2/angle.js

@@ -1 +1 @@
-module.exports = require('./angleRadians')
+export { angleRadians as angle } from './angleRadians.js'

package/src/maths/vec2/angleDegrees.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from './type'
+import type { Vec2 } from './type.d.ts'
 
-export default angleDegrees
-
-declare function angleDegrees(vector: Vec2): number
+export function angleDegrees(vector: Vec2): number