@jbroll/jscad-modeling 2.12.7

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

@@ -0,0 +1,36 @@
+const test = require('ava')
+const { multiply, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: multiply() called with three parameters should update a vec2 with correct values', (t) => {
+  const obs1 = fromValues(0, 0)
+  const ret1 = multiply(obs1, [0, 0], [0, 0])
+  t.true(compareVectors(obs1, [0, 0]))
+  t.true(compareVectors(ret1, [0, 0]))
+
+  const obs2 = fromValues(0, 0)
+  const ret2 = multiply(obs2, [0, 0], [1, 2])
+  t.true(compareVectors(obs2, [0, 0]))
+  t.true(compareVectors(ret2, [0, 0]))
+
+  const obs3 = fromValues(0, 0)
+  const ret3 = multiply(obs3, [6, 6], [1, 2])
+  t.true(compareVectors(obs3, [6, 12]))
+  t.true(compareVectors(ret3, [6, 12]))
+
+  const obs4 = fromValues(0, 0)
+  const ret4 = multiply(obs4, [-6, -6], [1, 2])
+  t.true(compareVectors(obs4, [-6, -12]))
+  t.true(compareVectors(ret4, [-6, -12]))
+
+  const obs5 = fromValues(0, 0)
+  const ret5 = multiply(obs5, [6, 6], [-1, -2])
+  t.true(compareVectors(obs5, [-6, -12]))
+  t.true(compareVectors(ret5, [-6, -12]))
+
+  const obs6 = fromValues(0, 0)
+  const ret6 = multiply(obs6, [-6, -6], [-1, -2])
+  t.true(compareVectors(obs6, [6, 12]))
+  t.true(compareVectors(ret6, [6, 12]))
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default negate
+
+declare function negate(out: Vec2, vec: Vec2): Vec2

package/src/maths/vec2/negate.js

@@ -0,0 +1,15 @@
+/**
+ * Negates the coordinates of the given vector.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {vec2} vector - vector to negate
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.negate
+ */
+const negate = (out, vector) => {
+  out[0] = -vector[0]
+  out[1] = -vector[1]
+  return out
+}
+
+module.exports = negate

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

@@ -0,0 +1,26 @@
+const test = require('ava')
+const { negate, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: negate() called with two parameters should update a vec2 with correct values', (t) => {
+  const obs1 = fromValues(0, 0)
+  const ret1 = negate(obs1, [0, 0])
+  t.true(compareVectors(obs1, [0, 0]))
+  t.true(compareVectors(ret1, [0, 0]))
+
+  const obs2 = fromValues(0, 0)
+  const ret2 = negate(obs2, [1, 2])
+  t.true(compareVectors(obs2, [-1, -2]))
+  t.true(compareVectors(ret2, [-1, -2]))
+
+  const obs3 = fromValues(0, 0)
+  const ret3 = negate(obs3, [-1, -2])
+  t.true(compareVectors(obs3, [1, 2]))
+  t.true(compareVectors(ret3, [1, 2]))
+
+  const obs4 = fromValues(0, 0)
+  const ret4 = negate(obs4, [-1, 2])
+  t.true(compareVectors(obs4, [1, -2]))
+  t.true(compareVectors(ret4, [1, -2]))
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default normal
+
+declare function normal(out: Vec2, vec:  Vec2): Vec2

package/src/maths/vec2/normal.js

@@ -0,0 +1,17 @@
+const { TAU } = require('../constants')
+
+const create = require('./create')
+const rotate = require('./rotate')
+
+/**
+ * Calculates the normal of the given vector.
+ * The normal value is the given vector rotated 90 degrees.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {vec2} vector - given value
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.normal
+ */
+const normal = (out, vector) => rotate(out, vector, create(), (TAU / 4))
+
+module.exports = normal

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

@@ -0,0 +1,30 @@
+const test = require('ava')
+const { create, normal } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: normal() with two params should update a vec2 with correct values', (t) => {
+  const out1 = create()
+  const ret1 = normal(out1, [0, 0])
+  t.true(compareVectors(out1, [0, 0]))
+  t.true(compareVectors(ret1, [0, 0]))
+  t.is(out1, ret1)
+
+  const out2 = create()
+  const ret2 = normal(out2, [1, 2])
+  t.true(compareVectors(out2, [-2, 1], 1e-15))
+  t.true(compareVectors(ret2, [-2, 1], 1e-15))
+  t.is(out2, ret2)
+
+  const out3 = create()
+  const ret3 = normal(out3, [-1, -2])
+  t.true(compareVectors(out3, [2, -1], 1e-15))
+  t.true(compareVectors(ret3, [2, -1], 1e-15))
+  t.is(out3, ret3)
+
+  const out4 = create()
+  const ret4 = normal(out4, [-1, 2])
+  t.true(compareVectors(out4, [-2, -1], 1e-15))
+  t.true(compareVectors(ret4, [-2, -1], 1e-15))
+  t.is(out4, ret4)
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default normalize
+
+declare function normalize(out: Vec2, vector: Vec2): Vec2

package/src/maths/vec2/normalize.js

@@ -0,0 +1,23 @@
+/**
+ * Normalize the given vector.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {vec2} vector - vector to normalize
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.normalize
+ */
+const normalize = (out, vector) => {
+  const x = vector[0]
+  const y = vector[1]
+  let len = x * x + y * y
+  if (len > 0) {
+    len = 1 / Math.sqrt(len)
+  }
+  out[0] = x * len
+  out[1] = y * len
+  return out
+}
+
+// old this.dividedBy(this.length())
+
+module.exports = normalize

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

@@ -0,0 +1,36 @@
+const test = require('ava')
+const { normalize, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: normalize() called with two parameters should update a vec2 with correct values', (t) => {
+  const obs1 = fromValues(0, 0)
+  const ret1 = normalize(obs1, [0, 0])
+  t.true(compareVectors(obs1, [0, 0]))
+  t.true(compareVectors(ret1, [0, 0]))
+
+  const obs2 = fromValues(0, 0)
+  const ret2 = normalize(obs2, [1, 2])
+  t.true(compareVectors(obs2, [0.4472135954999579, 0.8944271909999159]))
+  t.true(compareVectors(ret2, [0.4472135954999579, 0.8944271909999159]))
+
+  const obs3 = fromValues(0, 0)
+  const ret3 = normalize(obs3, [-1, -2])
+  t.true(compareVectors(obs3, [-0.4472135954999579, -0.8944271909999159]))
+  t.true(compareVectors(ret3, [-0.4472135954999579, -0.8944271909999159]))
+
+  const obs4 = fromValues(0, 0)
+  const ret4 = normalize(obs4, [-1, 2])
+  t.true(compareVectors(obs4, [-0.4472135954999579, 0.8944271909999159]))
+  t.true(compareVectors(ret4, [-0.4472135954999579, 0.8944271909999159]))
+
+  const obs5 = fromValues(0, 0)
+  const ret5 = normalize(obs5, [0.5, 1.5])
+  t.true(compareVectors(obs5, [0.31622776601683794, 0.9486832980505138]))
+  t.true(compareVectors(ret5, [0.31622776601683794, 0.9486832980505138]))
+
+  const obs6 = fromValues(0, 0)
+  const ret6 = normalize(obs6, [0.5, 0.5])
+  t.true(compareVectors(obs6, [0.7071067811865475, 0.7071067811865475]))
+  t.true(compareVectors(ret6, [0.7071067811865475, 0.7071067811865475]))
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default rotate
+
+declare function rotate(out: Vec2, vector: Vec2, origin: Vec2, angle: number): Vec2

package/src/maths/vec2/rotate.js

@@ -0,0 +1,23 @@
+/**
+ * Rotates the given vector by the given angle.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {vec2} vector - vector to rotate
+ * @param {vec2} origin - origin of the rotation
+ * @param {Number} radians - angle of rotation (radians)
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.rotate
+ */
+const rotate = (out, vector, origin, radians) => {
+  const x = vector[0] - origin[0]
+  const y = vector[1] - origin[1]
+  const c = Math.cos(radians)
+  const s = Math.sin(radians)
+
+  out[0] = x * c - y * s + origin[0]
+  out[1] = x * s + y * c + origin[1]
+
+  return out
+}
+
+module.exports = rotate

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

@@ -0,0 +1,31 @@
+const test = require('ava')
+
+const { TAU } = require('../constants')
+
+const { rotate, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: rotate() called with three parameters should update a vec2 with correct values', (t) => {
+  const radians = TAU / 4
+
+  const obs1 = fromValues(0, 0)
+  const ret1 = rotate(obs1, [0, 0], [0, 0], 0)
+  t.true(compareVectors(obs1, [0, 0]))
+  t.true(compareVectors(ret1, [0, 0]))
+
+  const obs2 = fromValues(0, 0)
+  const ret2 = rotate(obs2, [1, 2], [0, 0], 0)
+  t.true(compareVectors(obs2, [1, 2]))
+  t.true(compareVectors(ret2, [1, 2]))
+
+  const obs3 = fromValues(0, 0)
+  const ret3 = rotate(obs3, [-1, -2], [0, 0], radians)
+  t.true(compareVectors(obs3, [2, -1], 1e-15))
+  t.true(compareVectors(ret3, [2, -1], 1e-15))
+
+  const obs4 = fromValues(0, 0)
+  const ret4 = rotate(obs4, [-1, 2], [-3, -3], -radians)
+  t.true(compareVectors(obs4, [2, -5], 1e-15))
+  t.true(compareVectors(ret4, [2, -5], 1e-15))
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default scale
+
+declare function scale(out: Vec2, vector: Vec2, amount: number): Vec2

package/src/maths/vec2/scale.js

@@ -0,0 +1,16 @@
+/**
+ * Scales the coordinates of the given vector.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {vec2} vector - vector to scale
+ * @param {Number} amount - amount to scale
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.scale
+ */
+const scale = (out, vector, amount) => {
+  out[0] = vector[0] * amount
+  out[1] = vector[1] * amount
+  return out
+}
+
+module.exports = scale

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

@@ -0,0 +1,24 @@
+const test = require('ava')
+const { scale, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: scale() with two params should update a vec2 with positive values', (t) => {
+  const vec1 = create()
+  const ret1 = scale(vec1, [0, 0], 0)
+  t.true(compareVectors(vec1, [0, 0]))
+  t.true(compareVectors(ret1, [0, 0]))
+  t.is(vec1, ret1)
+
+  const vec2 = create()
+  const ret2 = scale(vec2, [1, 2], 3)
+  t.true(compareVectors(vec2, [3, 6]))
+  t.true(compareVectors(ret2, [3, 6]))
+  t.is(vec2, ret2)
+
+  const vec3 = create()
+  const ret3 = scale(vec3, [-1, -2], 3)
+  t.true(compareVectors(vec3, [-3, -6]))
+  t.true(compareVectors(ret3, [-3, -6]))
+  t.is(vec3, ret3)
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default snap
+
+declare function snap(out: Vec2, vector: Vec2, epsilon: number): Vec2

package/src/maths/vec2/snap.js

@@ -0,0 +1,16 @@
+/**
+ * Snaps the coordinates of the given vector to the given epsilon.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {vec2} vector - vector to snap
+ * @param {Number} epsilon - epsilon of precision, less than 0
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.snap
+ */
+const snap = (out, vector, epsilon) => {
+  out[0] = Math.round(vector[0] / epsilon) * epsilon + 0
+  out[1] = Math.round(vector[1] / epsilon) * epsilon + 0
+  return out
+}
+
+module.exports = snap

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

@@ -0,0 +1,32 @@
+const test = require('ava')
+const { snap, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: snap() should return vec2 with correct values', (t) => {
+  const output = create()
+
+  const obs1 = snap(output, [0, 0], 0.1)
+  t.true(compareVectors(obs1, [0, 0]))
+  t.true(compareVectors(output, [0, 0]))
+
+  const obs2 = snap(output, [1, 2], 0.1)
+  t.true(compareVectors(obs2, [1, 2]))
+  t.true(compareVectors(output, [1, 2]))
+
+  const obs3 = snap(output, [-1, -2], 0.01)
+  t.true(compareVectors(obs3, [-1, -2]))
+  t.true(compareVectors(output, [-1, -2]))
+
+  const obs4 = snap(output, [-1.123456789, -2.123456789], 0.01)
+  t.true(compareVectors(obs4, [-1.12, -2.12]))
+  t.true(compareVectors(output, [-1.12, -2.12]))
+
+  const obs5 = snap(output, [-1.123456789, -2.123456789], 0.0001)
+  t.true(compareVectors(obs5, [-1.1235, -2.1235]))
+  t.true(compareVectors(output, [-1.1235, -2.1235]))
+
+  const obs6 = snap(output, [-1.123456789, -2.123456789], 0.000001)
+  t.true(compareVectors(obs6, [-1.123457, -2.1234569999999997]))
+  t.true(compareVectors(output, [-1.123457, -2.1234569999999997]))
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default squaredDistance
+
+declare function squaredDistance(a: Vec2, b: Vec2): number

package/src/maths/vec2/squaredDistance.js

@@ -0,0 +1,15 @@
+/**
+ * Calculates the squared distance between the given vectors.
+ *
+ * @param {vec2} a - first operand
+ * @param {vec2} b - second operand
+ * @returns {Number} squared distance
+ * @alias module:modeling/maths/vec2.squaredDistance
+ */
+const squaredDistance = (a, b) => {
+  const x = b[0] - a[0]
+  const y = b[1] - a[1]
+  return x * x + y * y
+}
+
+module.exports = squaredDistance

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

@@ -0,0 +1,30 @@
+const test = require('ava')
+const { squaredDistance, fromValues } = require('./index')
+
+const { nearlyEqual } = require('../../../test/helpers/index')
+const { EPS } = require('../constants')
+
+test('vec2: squaredDistance() should return correct values', (t) => {
+  const vec0 = fromValues(0, 0)
+  const vec1 = fromValues(0, 0)
+  const distance1 = squaredDistance(vec0, vec1)
+  nearlyEqual(t, distance1, 0.0, EPS)
+
+  const vec2 = fromValues(1, 2)
+  const distance2 = squaredDistance(vec0, vec2)
+  nearlyEqual(t, distance2, 5.00000, EPS)
+
+  const vec3 = fromValues(1, -2)
+  const distance3 = squaredDistance(vec0, vec3)
+  nearlyEqual(t, distance3, 5.00000, EPS)
+
+  const vec4 = fromValues(-1, -2)
+  const distance4 = squaredDistance(vec0, vec4)
+  nearlyEqual(t, distance4, 5.00000, EPS)
+
+  const vec5 = fromValues(-1, 2)
+  const distance5 = squaredDistance(vec0, vec5)
+  nearlyEqual(t, distance5, 5.00000, EPS)
+
+  t.true(true)
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default squaredLength
+
+declare function squaredLength(vector: Vec2): number

package/src/maths/vec2/squaredLength.js

@@ -0,0 +1,14 @@
+/**
+ * Calculates the squared length of the given vector.
+ *
+ * @param {vec2} vector - vector of reference
+ * @returns {Number} squared length
+ * @alias module:modeling/maths/vec2.squaredLength
+ */
+const squaredLength = (vector) => {
+  const x = vector[0]
+  const y = vector[1]
+  return x * x + y * y
+}
+
+module.exports = squaredLength

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

@@ -0,0 +1,29 @@
+const test = require('ava')
+const { squaredLength, fromValues } = require('./index')
+
+const { nearlyEqual } = require('../../../test/helpers/index')
+const { EPS } = require('../constants')
+
+test('vec2: length() should return correct values', (t) => {
+  const vec1 = fromValues(0, 0)
+  const length1 = squaredLength(vec1)
+  nearlyEqual(t, length1, 0.0, EPS)
+
+  const vec2 = fromValues(1, 2)
+  const length2 = squaredLength(vec2)
+  nearlyEqual(t, length2, 5.00000, EPS)
+
+  const vec3 = fromValues(1, -2)
+  const length3 = squaredLength(vec3)
+  nearlyEqual(t, length3, 5.00000, EPS)
+
+  const vec4 = fromValues(-1, -2)
+  const length4 = squaredLength(vec4)
+  nearlyEqual(t, length4, 5.00000, EPS)
+
+  const vec5 = fromValues(-1, 2)
+  const length5 = squaredLength(vec5)
+  nearlyEqual(t, length5, 5.00000, EPS)
+
+  t.true(true)
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default subtract
+
+declare function subtract(out: Vec2, a: Vec2, b: Vec2): Vec2

package/src/maths/vec2/subtract.js

@@ -0,0 +1,16 @@
+/**
+ * Subtracts 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
+ * @alias module:modeling/maths/vec2.subtract
+ */
+const subtract = (out, a, b) => {
+  out[0] = a[0] - b[0]
+  out[1] = a[1] - b[1]
+  return out
+}
+
+module.exports = subtract

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

@@ -0,0 +1,26 @@
+const test = require('ava')
+const { subtract, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: subtract() called with three parameters should update a vec2 with correct values', (t) => {
+  const obs1 = fromValues(0, 0)
+  const ret1 = subtract(obs1, [0, 0], [0, 0])
+  t.true(compareVectors(obs1, [0, 0]))
+  t.true(compareVectors(ret1, [0, 0]))
+
+  const obs2 = fromValues(0, 0)
+  const ret2 = subtract(obs2, [1, 2], [3, 2])
+  t.true(compareVectors(obs2, [-2, 0]))
+  t.true(compareVectors(ret2, [-2, 0]))
+
+  const obs3 = fromValues(0, 0)
+  const ret3 = subtract(obs3, [1, 2], [-1, -2])
+  t.true(compareVectors(obs3, [2, 4]))
+  t.true(compareVectors(ret3, [2, 4]))
+
+  const obs4 = fromValues(0, 0)
+  const ret4 = subtract(obs4, [-1, -2], [-1, -2])
+  t.true(compareVectors(obs4, [0, 0]))
+  t.true(compareVectors(ret4, [0, 0]))
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default toString
+
+declare function toString(vec: Vec2): string

package/src/maths/vec2/toString.js

@@ -0,0 +1,10 @@
+/**
+ * Convert the given vector to a representative string.
+ *
+ * @param {vec2} vector - vector of reference
+ * @returns {String} string representation
+ * @alias module:modeling/maths/vec2.toString
+ */
+const toString = (vector) => `[${vector[0].toFixed(7)}, ${vector[1].toFixed(7)}]`
+
+module.exports = toString

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

@@ -0,0 +1,6 @@
+import Vec2 from './type'
+import Mat4 from '../mat4/type'
+
+export default transform
+
+declare function transform(out: Vec2, vector: Vec2, matrix: Mat4): Vec2

package/src/maths/vec2/transform.js

@@ -0,0 +1,18 @@
+/**
+ * Transforms the given vector using the given matrix.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {vec2} vector - vector to transform
+ * @param {mat4} matrix - matrix to transform with
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.transform
+ */
+const transform = (out, vector, matrix) => {
+  const x = vector[0]
+  const y = vector[1]
+  out[0] = matrix[0] * x + matrix[4] * y + matrix[12]
+  out[1] = matrix[1] * x + matrix[5] * y + matrix[13]
+  return out
+}
+
+module.exports = transform

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

@@ -0,0 +1,66 @@
+const test = require('ava')
+const { transform, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: transform() called with three parameters should update a vec2 with correct values', (t) => {
+  const identityMatrix = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const obs1 = fromValues(0, 0)
+  const ret1 = transform(obs1, [0, 0], identityMatrix)
+  t.true(compareVectors(obs1, [0, 0]))
+  t.true(compareVectors(ret1, [0, 0]))
+
+  const obs2 = fromValues(0, 0)
+  const ret2 = transform(obs2, [3, 2], identityMatrix)
+  t.true(compareVectors(obs2, [3, 2]))
+  t.true(compareVectors(ret2, [3, 2]))
+
+  const x = 1
+  const y = 5
+  const z = 7
+  const translationMatrix = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    x, y, z, 1
+  ]
+
+  const obs3 = fromValues(0, 0)
+  const ret3 = transform(obs3, [-1, -2], translationMatrix)
+  t.true(compareVectors(obs3, [0, 3]))
+  t.true(compareVectors(ret3, [0, 3]))
+
+  const w = 1
+  const h = 3
+  const d = 5
+  const scaleMatrix = [
+    w, 0, 0, 0,
+    0, h, 0, 0,
+    0, 0, d, 0,
+    0, 0, 0, 1
+  ]
+
+  const obs4 = fromValues(0, 0)
+  const ret4 = transform(obs4, [1, 2], scaleMatrix)
+  t.true(compareVectors(obs4, [1, 6]))
+  t.true(compareVectors(ret4, [1, 6]))
+
+  const r = (90 * 0.017453292519943295)
+  const rotateZMatrix = [
+    Math.cos(r), -Math.sin(r), 0, 0,
+    Math.sin(r), Math.cos(r), 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const obs5 = fromValues(0, 0)
+  const ret5 = transform(obs5, [1, 2], rotateZMatrix)
+  t.true(compareVectors(obs5, [2, -1]))
+  t.true(compareVectors(ret5, [2, -1]))
+})

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

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

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

@@ -0,0 +1,5 @@
+import Vec3 from './type'
+
+export default abs
+
+declare function abs(out: Vec3, vector: Vec3): Vec3