vec3 0.1.7 → 0.1.9

package/.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10

package/.github/workflows/ci.yml

@@ -13,7 +13,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [12.x]
+        node-version: [18.x]
 
     steps:
     - uses: actions/checkout@v2

package/.github/workflows/commands.yml

@@ -0,0 +1,22 @@
+name: Repo Commands
+
+on:
+  issue_comment:        # Handle comment commands
+    types: [created]
+  pull_request:         # Handle renamed PRs
+    types: [edited]
+
+jobs:
+  comment-trigger:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v3
+    - name: Run command handlers
+      uses: PrismarineJS/prismarine-repo-actions@master
+      with:
+        # NOTE: You must specify a Personal Access Token (PAT) with repo access here. While you can use the default GITHUB_TOKEN, actions taken with it will not trigger other actions, so if you have a CI workflow, commits created by this action will not trigger it.
+        token: ${{ secrets.PAT_PASSWORD }}
+        # See `Options` section below for more info on these options
+        install-command: npm install
+        /fixlint.fix-command: npm run fix

package/.github/workflows/publish.yml

@@ -13,13 +13,20 @@ jobs:
     - name: Set up Node.js
       uses: actions/setup-node@master
       with:
-        node-version: 10.0.0
-    - name: Publish if version has been updated
-      uses: pascalgn/npm-publish-action@4f4bf159e299f65d21cd1cbd96fc5d53228036df
-      with: # All of theses inputs are optional
-        tag_name: "%s"
-        tag_message: "%s"
-        commit_pattern: "^Release (\\S+)"
-      env: # More info about the environment variables in the README
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # Leave this as is, it's automatically generated
-        NPM_AUTH_TOKEN: ${{ secrets.NPM_AUTH_TOKEN }} # You need to set this in your repo settings
+        node-version: 18.0.0
+    - id: publish
+      uses: JS-DevTools/npm-publish@v1
+      with:
+        token: ${{ secrets.NPM_AUTH_TOKEN }}
+    - name: Create Release
+      if: steps.publish.outputs.type != 'none'
+      id: create_release
+      uses: actions/create-release@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        tag_name: ${{ steps.publish.outputs.version }}
+        release_name: Release ${{ steps.publish.outputs.version }}
+        body: ${{ steps.publish.outputs.version }}
+        draft: false
+        prerelease: false

package/HISTORY.md

@@ -1,3 +1,14 @@
+## 0.1.9
+* [Add methods, fix .equals (#46)](https://github.com/PrismarineJS/node-vec3/commit/c6b94c4289cfba5fc460bed99d112cec85fe1cf3) (thanks @szdytom)
+* [Add command gh workflow allowing to use release command in comments (#45)](https://github.com/PrismarineJS/node-vec3/commit/8675f8ecf6065278c0d1f889a585a5febf446cc0) (thanks @rom1504)
+* [Update to node 18.0.0 (#44)](https://github.com/PrismarineJS/node-vec3/commit/358445025ff7d558c8f3fddec2d5786c8c468db5) (thanks @rom1504)
+* [New publish workflow (#38)](https://github.com/PrismarineJS/node-vec3/commit/ed6ba10a9b3d163f5c1ee8cb1b78108296b98477) (thanks @KTibow)
+
+## 0.1.8
+
+* fix some typescript stuff
+* new methods: rounded, round, multiply, and divide
+
 ## 0.1.7
 * fix standard not being a dev dependency
 

package/README.md

@@ -29,55 +29,65 @@ More available functions are listed below in Test Coverage.
 ## Test Coverage
 
 ```
-v()
-    ✓ no args
-    ✓ x, y, z
-    ✓ array
-    ✓ object
-    ✓ string coords
-    ✓ deserialize
-    ✓ invalid deserialize
+  v()
+    ✔ no args
+    ✔ x, y, z
+    ✔ array
+    ✔ object
+    ✔ string coords
+    ✔ deserialize
+    ✔ invalid deserialize
 
   vec3
-    ✓ floored
-    ✓ floor
-    ✓ offset
-    ✓ translate
-    ✓ plus
-    ✓ minus
-    ✓ scaled
-    ✓ abs
-    ✓ distanceTo
-    ✓ equals
-    ✓ toString
-    ✓ clone
-    ✓ add
-    ✓ subtract
-    ✓ set
-    ✓ modulus
-    ✓ volume
-    ✓ min
-    ✓ max
-    ✓ update
-    ✓ norm
-    ✓ dot
-    ✓ cross
-    ✓ unit
-    ✓ normalize
-    ✓ scale
-    ✓ xyDistanceTo
-    ✓ xzDistanceTo
-    ✓ yzDistanceTo
-    ✓ innerProduct
-    ✓ manhattanDistanceTo
-    ✓ toArray
-
-
-  39 passing
+    ✔ isZero
+    ✔ at
+    ✔ xz
+    ✔ xy
+    ✔ yz
+    ✔ xzy
+    ✔ rounded
+    ✔ round
+    ✔ floored
+    ✔ floor
+    ✔ offset
+    ✔ translate
+    ✔ plus
+    ✔ minus
+    ✔ scaled
+    ✔ abs
+    ✔ distanceTo
+    ✔ distanceSquared
+    ✔ equals
+    ✔ toString
+    ✔ clone
+    ✔ add
+    ✔ subtract
+    ✔ multiply
+    ✔ divide
+    ✔ set
+    ✔ modulus
+    ✔ volume
+    ✔ min
+    ✔ max
+    ✔ update
+    ✔ norm
+    ✔ dot
+    ✔ cross
+    ✔ unit
+    ✔ normalize
+    ✔ scale
+    ✔ xyDistanceTo
+    ✔ xzDistanceTo
+    ✔ yzDistanceTo
+    ✔ innerProduct
+    ✔ manhattanDistanceTo
+    ✔ toArray
+
+  50 passing (14ms)
 ```
 
 More functions welcome in the form of pull requests.
 
 ## History
 
-See [History](History.md)
+See [History](HISTORY.md)

package/index.d.ts

@@ -1,79 +1,237 @@
 export class Vec3 {
-    constructor(x: number, y: number, z: number);
-
-    x: number;
-    y: number;
-    z: number;
-
-    set(x: number, y: number, z: number): this;
-
-    update(other: Vec3): this;
-
-    floored(): Vec3;
-
-    floor(): this;
-
-    offset(dx: number, dy: number, dz: number): Vec3;
-
-    translate(dx: number, dy: number, dz: number): this;
-
-    add(other: Vec3): this;
-
-    subtract(other: Vec3): this;
-
-    plus(other: Vec3): Vec3;
-
-    minus(other: Vec3): Vec3;
-
-    scaled(scalar: number): Vec3;
-
-    abs(): Vec3;
-
-    volume(): number;
-
-    modulus(other: Vec3): Vec3;
-
-    distanceTo(other: Vec3): number;
-
-    distanceSquared(other: Vec3): number;
-
-    equals(other: Vec3): boolean;
-
-    toString(): string;
-
-    clone(): Vec3;
-
-    min(other: Vec3): Vec3;
-
-    max(other: Vec3): Vec3;
-
-    dot(other: Vec3): number;
-
-    cross(other: Vec3): Vec3;
-
-    norm(): number;
-
-    unit(): Vec3;
-
-    normalize(): Vec3;
-
-    scale(scalar: number): this;
-
-    xyDistanceTo(other: Vec3): number;
-
-    xzDistanceTo(other: Vec3): number;
-
-    yzDistanceTo(other: Vec3): number;
-
-    innerProduct(other: Vec3): number;
-
-    manhattanDistanceTo(other: Vec3): number;
-
-    toArray(): Array<number>;
+  constructor(x: number, y: number, z: number);
+
+  x: number;
+  y: number;
+  z: number;
+
+  /**
+   * Returns true when it is a zero vector.
+   */
+  isZero(): boolean;
+
+  /**
+   * Access component by index
+   */
+  at(id: number): number;
+
+  /**
+   * Returns an array component x, z
+   */
+  xz(): [number, number];
+
+  /**
+   * Returns an array component x, y
+   */
+  xy(): [number, number];
+
+  /**
+   * Returns an array component y, z
+   */
+  yz(): [number, number];
+
+  /**
+   * Returns a vector with swapped y and z
+   */
+  xzy(): Vec3;
+
+  /**
+   * Set own values to given x y z
+   * If some components is given null, then those components won't change
+   */
+  set(x: number, y: number, z: number): this;
+
+  /**
+   * Set own values to values given by other
+   */
+  update(other: Vec3): this;
+
+  /**
+   * Return a new instance with copied values that are rounded
+   */
+  rounded(): Vec3;
+
+  /**
+   * Round own values to nearest integer
+   */
+  round(): this;
+
+  /**
+   * Return a new instance with copied values that are floored
+   */
+  floored(): Vec3;
+
+  /**
+   * Floor own values
+   */
+  floor(): this;
+
+  /**
+   * Return a new instance with copied values that are offset by dx dy and dz
+   */
+  offset(dx: number, dy: number, dz: number): Vec3;
+
+  /**
+   * Translate own values by dx dy and dz
+   */
+  translate(dx: number, dy: number, dz: number): this;
+
+  /**
+   * Add to own values by vector
+   */
+  add(other: Vec3): this;
+
+  /**
+   * Subtract own values by vector
+   */
+  subtract(other: Vec3): this;
+
+  /**
+   * Multiply own values by value from vector
+   */
+  multiply(other: Vec3): this;
+
+  /**
+   * Divide own values by value from vector
+   */
+  divide(other: Vec3): this;
+
+  /**
+   * Return a new instance with copied values that are added to by vector
+   */
+  plus(other: Vec3): Vec3;
+
+  /**
+   * Return a new instance with copied values that are subtracted by vector
+   */
+  minus(other: Vec3): Vec3;
+
+  /**
+   * Return a new instance with copied values that are scaled by number
+   */
+  scaled(scalar: number): Vec3;
+
+  /**
+   * Return a new instance with copied values that are absolute
+   */
+  abs(): Vec3;
+
+  /**
+   * Return the volume off the vector
+   */
+  volume(): number;
+
+  /**
+   * Return a new instance with copied values that are modulated by value from a vector
+   */
+  modulus(other: Vec3): Vec3;
+
+  /**
+   * Return the euclidean distance to another vector 
+   */
+  distanceTo(other: Vec3): number;
+
+  /**
+   * Return the squared euclidean distance to another vector
+   */
+  distanceSquared(other: Vec3): number;
+
+  /**
+   * Check whether two vectors are equal
+   * Returns true if each components have at most `error` difference
+   */
+  equals(other: Vec3, error?: number): boolean;
+
+  /**
+   * Converts own values to a string representation in the format `(x, y, z)`
+   */
+  toString(): string;
+
+  /**
+   * Return a new instance with the same values
+   */
+  clone(): Vec3;
+
+  /**
+   * Return a new instance with the min values by value compared to another vector
+   */
+  min(other: Vec3): Vec3;
+
+  /**
+   * Return a new instance with the max values by value compared to another vector
+   */
+  max(other: Vec3): Vec3;
+
+  /**
+   * Returns its own euclidean norm
+   */
+  norm(): number;
+
+  /**
+   * Returns the dot product with another vector
+   */
+  dot(other: Vec3): number;
+
+  /**
+   * Returns a new instance off the cross product to another vector
+   */
+  cross(other: Vec3): Vec3;
+
+  /**
+   * Returns a new instance with copied values normed to the unit vector
+   */
+  unit(): Vec3;
+
+  /**
+   * Normalize own values
+   */
+  normalize(): Vec3;
+
+  /**
+   * Scale own values by a number
+   */
+  scale(scalar: number): this;
+
+  /**
+   * Returns the xy distance to another vector
+   */
+  xyDistanceTo(other: Vec3): number;
+
+  /**
+   * Returns the xz distance to another vector
+   */
+  xzDistanceTo(other: Vec3): number;
+
+  /**
+   * Returns the yz distance to another vector
+   */
+  yzDistanceTo(other: Vec3): number;
+
+  /**
+   * Returns the inner product to another vector
+   */
+  innerProduct(other: Vec3): number;
+
+  /**
+   * Returns the manhattan distance to another vector
+   */
+  manhattanDistanceTo(other: Vec3): number;
+
+  /**
+   * Returns an array with x y z in array form ie [x, y, z]
+   */
+  toArray(): [number, number, number];
 }
 
 export default function v(
-    x: null | Array<number | string> | {x: number | string, y: number | string, z: number | string} | string,
-    y?: number | string,
-    z?: number | string
+  coordinates:
+    | null
+    | string
+    | [number | string, number | string, number | string]
+    | { x: number | string; y: number | string; z: number | string }
+): Vec3;
+export default function v(
+  x: number | string,
+  y: number | string,
+  z: number | string
 ): Vec3;

package/index.js

@@ -7,6 +7,30 @@ class Vec3 {
     this.z = z
   }
 
+  isZero () {
+    return this.x === 0 && this.y === 0 && this.z === 0
+  }
+
+  at (id) {
+    return this.toArray()[id]
+  }
+
+  xz () {
+    return [this.x, this.z]
+  }
+
+  xy () {
+    return [this.x, this.y]
+  }
+
+  yz () {
+    return [this.y, this.z]
+  }
+
+  xzy () {
+    return new Vec3(this.x, this.z, this.y)
+  }
+
   set (x, y, z) {
     this.x = x
     this.y = y
@@ -21,6 +45,17 @@ class Vec3 {
     return this
   }
 
+  rounded () {
+    return new Vec3(Math.round(this.x), Math.round(this.y), Math.round(this.z))
+  }
+
+  round () {
+    this.x = Math.round(this.x)
+    this.y = Math.round(this.y)
+    this.z = Math.round(this.z)
+    return this
+  }
+
   floored () {
     return new Vec3(Math.floor(this.x), Math.floor(this.y), Math.floor(this.z))
   }
@@ -57,6 +92,20 @@ class Vec3 {
     return this
   }
 
+  multiply (other) {
+    this.x *= other.x
+    this.y *= other.y
+    this.z *= other.z
+    return this
+  }
+
+  divide (other) {
+    this.x /= other.x
+    this.y /= other.y
+    this.z /= other.z
+    return this
+  }
+
   plus (other) {
     return this.offset(other.x, other.y, other.z)
   }
@@ -85,21 +134,23 @@ class Vec3 {
   }
 
   distanceTo (other) {
-    var dx = other.x - this.x
-    var dy = other.y - this.y
-    var dz = other.z - this.z
+    const dx = other.x - this.x
+    const dy = other.y - this.y
+    const dz = other.z - this.z
     return Math.sqrt(dx * dx + dy * dy + dz * dz)
   }
 
   distanceSquared (other) {
-    var dx = other.x - this.x
-    var dy = other.y - this.y
-    var dz = other.z - this.z
+    const dx = other.x - this.x
+    const dy = other.y - this.y
+    const dz = other.z - this.z
     return dx * dx + dy * dy + dz * dz
   }
 
-  equals (other) {
-    return this.x === other.x && this.y === other.y && this.z === other.z
+  equals (other, error = 0) {
+    return Math.abs(this.x - other.x) <= error &&
+      Math.abs(this.y - other.y) <= error &&
+      Math.abs(this.z - other.z) <= error
   }
 
   toString () {
@@ -157,20 +208,20 @@ class Vec3 {
   }
 
   xyDistanceTo (other) {
-    var dx = other.x - this.x
-    var dy = other.y - this.y
+    const dx = other.x - this.x
+    const dy = other.y - this.y
     return Math.sqrt(dx * dx + dy * dy)
   }
 
   xzDistanceTo (other) {
-    var dx = other.x - this.x
-    var dz = other.z - this.z
+    const dx = other.x - this.x
+    const dz = other.z - this.z
     return Math.sqrt(dx * dx + dz * dz)
   }
 
   yzDistanceTo (other) {
-    var dy = other.y - this.y
-    var dz = other.z - this.z
+    const dy = other.y - this.y
+    const dz = other.z - this.z
     return Math.sqrt(dy * dy + dz * dz)
   }
 
@@ -191,26 +242,26 @@ function v (x, y, z) {
   if (x == null) {
     return new Vec3(0, 0, 0)
   } else if (Array.isArray(x)) {
-    return new Vec3(parseFloat(x[0], 10), parseFloat(x[1], 10), parseFloat(x[2], 10))
+    return new Vec3(parseFloat(x[0]), parseFloat(x[1]), parseFloat(x[2]))
   } else if (typeof x === 'object') {
-    return new Vec3(parseFloat(x.x, 10), parseFloat(x.y, 10), parseFloat(x.z, 10))
+    return new Vec3(parseFloat(x.x), parseFloat(x.y), parseFloat(x.z))
   } else if (typeof x === 'string' && y == null) {
-    var match = x.match(re)
+    const match = x.match(re)
     if (match) {
       return new Vec3(
-        parseFloat(match[1], 10),
-        parseFloat(match[2], 10),
-        parseFloat(match[3], 10))
+        parseFloat(match[1]),
+        parseFloat(match[2]),
+        parseFloat(match[3]))
     } else {
       throw new Error('vec3: cannot parse: ' + x)
     }
   } else {
-    return new Vec3(parseFloat(x, 10), parseFloat(y, 10), parseFloat(z, 10))
+    return new Vec3(parseFloat(x), parseFloat(y), parseFloat(z))
   }
 }
 
 function euclideanMod (numerator, denominator) {
-  var result = numerator % denominator
+  const result = numerator % denominator
   return result < 0 ? result + denominator : result
 }
 

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "vec3",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "3d vector math with good unit tests",
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
-    "test": "mocha --reporter spec",
+    "test": "npm run test-js && npm run test-types",
+    "test-js": "mocha --reporter spec",
+    "test-types": "tsd",
     "pretest": "npm run lint",
     "lint": "standard",
     "fix": "standard --fix"
@@ -13,12 +15,23 @@
   "keywords": [
     "point"
   ],
+  "exports": {
+    "require": "./index.js",
+    "import": "./wrapper.mjs"
+  },
   "author": "Andrew Kelley",
   "license": "BSD",
   "devDependencies": {
-    "mocha": "^7.2.0",
-    "standard": "^14.3.4"
+    "mocha": "^10.0.0",
+    "standard": "^17.0.0",
+    "tsd": "^0.25.0"
+  },
+  "dependencies": {},
+  "tsd": {
+    "directory": "test"
   },
-  "dependencies": {
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PrismarineJS/node-vec3.git"
   }
 }

package/test/index.test-d.ts

@@ -0,0 +1,60 @@
+import { expectType } from "tsd";
+import vec3, { Vec3 } from "..";
+
+const vec = vec3([1, 2, 3]);
+expectType<Vec3>(vec);
+expectType<Vec3>(vec3([1, 2, 3]));
+expectType<Vec3>(vec3({ x: 1, y: 2, z: 3 }));
+expectType<Vec3>(vec3("1, 2, 3"));
+expectType<Vec3>(vec3(1, 2, 3));
+expectType<Vec3>(new Vec3(1,2,3));
+// @ts-expect-error
+vec3(1, 2);
+// @ts-expect-error
+vec3("1", 2);
+
+expectType<number>(vec.x);
+expectType<number>(vec.y);
+expectType<number>(vec.z);
+
+expectType<boolean>(vec.isZero());
+expectType<number>(vec.at(1));
+expectType<[number, number]>(vec.xz());
+expectType<[number, number]>(vec.xy());
+expectType<[number, number]>(vec.yz());
+expectType<Vec3>(vec.xzy());
+expectType<Vec3>(vec.set(4, 5, 6));
+expectType<Vec3>(vec.update(vec));
+expectType<Vec3>(vec.floored());
+expectType<Vec3>(vec.floor());
+expectType<Vec3>(vec.offset(0, 0, 0));
+expectType<Vec3>(vec.translate(0, 0, 0));
+expectType<Vec3>(vec.add(vec));
+expectType<Vec3>(vec.subtract(vec));
+expectType<Vec3>(vec.multiply(vec));
+expectType<Vec3>(vec.divide(vec));
+expectType<Vec3>(vec.plus(vec));
+expectType<Vec3>(vec.minus(vec));
+expectType<Vec3>(vec.scaled(2));
+expectType<Vec3>(vec.abs());
+expectType<number>(vec.volume());
+expectType<Vec3>(vec.modulus(vec));
+expectType<number>(vec.distanceTo(vec));
+expectType<number>(vec.distanceSquared(vec));
+expectType<boolean>(vec.equals(vec));
+expectType<string>(vec.toString());
+expectType<Vec3>(vec.clone());
+expectType<Vec3>(vec.min(vec));
+expectType<Vec3>(vec.max(vec));
+expectType<number>(vec.norm());
+expectType<number>(vec.dot(vec));
+expectType<Vec3>(vec.cross(vec));
+expectType<Vec3>(vec.unit());
+expectType<Vec3>(vec.normalize());
+expectType<Vec3>(vec.scale(2));
+expectType<number>(vec.xyDistanceTo(vec));
+expectType<number>(vec.xzDistanceTo(vec));
+expectType<number>(vec.yzDistanceTo(vec));
+expectType<number>(vec.innerProduct(vec));
+expectType<number>(vec.manhattanDistanceTo(vec));
+expectType<[number, number, number]>(vec.toArray());

package/test/test.js

@@ -1,49 +1,49 @@
 /* eslint-env mocha */
 
-var v = require('../')
-var Vec3 = v.Vec3
-var assert = require('assert')
+const v = require('../')
+const Vec3 = v.Vec3
+const assert = require('assert')
 
 describe('v()', function () {
   it('no args', function () {
-    var v1 = v()
+    const v1 = v()
     assert.strictEqual(v1.x, 0)
     assert.strictEqual(v1.y, 0)
     assert.strictEqual(v1.z, 0)
   })
   it('x, y, z', function () {
-    var v1 = v(-1, 5, 10.10)
+    const v1 = v(-1, 5, 10.10)
     assert.strictEqual(v1.x, -1)
     assert.strictEqual(v1.y, 5)
     assert.strictEqual(v1.z, 10.10)
   })
   it('array', function () {
-    var v1 = v([4, 5, 6])
+    const v1 = v([4, 5, 6])
     assert.strictEqual(v1.x, 4)
     assert.strictEqual(v1.y, 5)
     assert.strictEqual(v1.z, 6)
   })
   it('object', function () {
-    var v1 = v({ x: 9, y: 8, z: 7 })
+    const v1 = v({ x: 9, y: 8, z: 7 })
     assert.strictEqual(v1.x, 9)
     assert.strictEqual(v1.y, 8)
     assert.strictEqual(v1.z, 7)
   })
   it('string coords', function () {
-    var v1 = v('1', '1.5', '-30.2')
+    const v1 = v('1', '1.5', '-30.2')
     assert.strictEqual(v1.x, 1)
     assert.strictEqual(v1.y, 1.5)
     assert.strictEqual(v1.z, -30.2)
   })
   it('deserialize', function () {
-    var v1 = v(v(1, -3.5, 0).toString())
+    const v1 = v(v(1, -3.5, 0).toString())
     assert.strictEqual(v1.x, 1)
     assert.strictEqual(v1.y, -3.5)
     assert.strictEqual(v1.z, 0)
-    var v2 = v(v(-111, 222, 9876543210.123456789).toString())
+    const v2 = v(v(-111, 222, 9876543210.12345).toString())
     assert.strictEqual(v2.x, -111)
     assert.strictEqual(v2.y, 222)
-    assert.strictEqual(v2.z, 9876543210.123456789)
+    assert.strictEqual(v2.z, 9876543210.12345)
   })
   it('invalid deserialize', function () {
     assert.throws(function () {
@@ -52,41 +52,94 @@ describe('v()', function () {
   })
 })
 describe('vec3', function () {
+  it('isZero', function () {
+    const v1 = new Vec3(0, 1, 2)
+    const v2 = new Vec3(0, 0, 0)
+    assert.ok(!v1.isZero())
+    assert.ok(v2.isZero())
+  })
+  it('at', function () {
+    const v1 = new Vec3(0, 1, 2)
+    assert.strictEqual(v1.at(0), 0)
+    assert.strictEqual(v1.at(1), 1)
+    assert.strictEqual(v1.at(2), 2)
+  })
+  it('xz', function () {
+    const v1 = new Vec3(0, 1, 2)
+    const a = v1.xz()
+    assert.strictEqual(a[0], 0)
+    assert.strictEqual(a[1], 2)
+  })
+  it('xy', function () {
+    const v1 = new Vec3(0, 1, 2)
+    const a = v1.xy()
+    assert.strictEqual(a[0], 0)
+    assert.strictEqual(a[1], 1)
+  })
+  it('yz', function () {
+    const v1 = new Vec3(0, 1, 2)
+    const a = v1.yz()
+    assert.strictEqual(a[0], 1)
+    assert.strictEqual(a[1], 2)
+  })
+  it('xzy', function () {
+    const v1 = new Vec3(0, 1, 2)
+    const v2 = v1.xzy()
+    assert.strictEqual(v2.x, 0)
+    assert.strictEqual(v2.y, 2)
+    assert.strictEqual(v2.z, 1)
+  })
+  it('rounded', function () {
+    const v1 = new Vec3(1.1, -1.5, 1.9)
+    const v2 = v1.rounded()
+    v1.x = 10
+    assert.strictEqual(v2.x, 1)
+    assert.strictEqual(v2.y, -1)
+    assert.strictEqual(v2.z, 2)
+  })
+  it('round', function () {
+    const v1 = new Vec3(1.1, -1.5, 1.9)
+    const v2 = v1.round()
+    assert.strictEqual(v2, v1)
+    assert.strictEqual(v1.x, 1)
+    assert.strictEqual(v1.y, -1)
+    assert.strictEqual(v1.z, 2)
+  })
   it('floored', function () {
-    var v1 = new Vec3(1.1, -1.5, 1.9)
-    var v2 = v1.floored()
+    const v1 = new Vec3(1.1, -1.5, 1.9)
+    const v2 = v1.floored()
     v1.x = 10
     assert.strictEqual(v2.x, 1)
     assert.strictEqual(v2.y, -2)
     assert.strictEqual(v2.z, 1)
   })
   it('floor', function () {
-    var v1 = new Vec3(1.1, -1.5, 1.9)
-    var v2 = v1.floor()
+    const v1 = new Vec3(1.1, -1.5, 1.9)
+    const v2 = v1.floor()
     assert.strictEqual(v2, v1)
     assert.strictEqual(v1.x, 1)
     assert.strictEqual(v1.y, -2)
     assert.strictEqual(v1.z, 1)
   })
   it('offset', function () {
-    var v1 = new Vec3(1, 2, 3)
-    var v2 = v1.offset(10, -10, 20)
+    const v1 = new Vec3(1, 2, 3)
+    const v2 = v1.offset(10, -10, 20)
     v1.x = -100
     assert.strictEqual(v2.x, 11)
     assert.strictEqual(v2.y, -8)
     assert.strictEqual(v2.z, 23)
   })
   it('translate', function () {
-    var v1 = new Vec3(1, 2, 3)
+    const v1 = new Vec3(1, 2, 3)
     v1.translate(10, -10, 20)
     assert.strictEqual(v1.x, 11)
     assert.strictEqual(v1.y, -8)
     assert.strictEqual(v1.z, 23)
   })
   it('plus', function () {
-    var v1 = new Vec3(1, 2, 3)
-    var v2 = new Vec3(-1, 0, 1)
-    var v3 = v1.plus(v2)
+    const v1 = new Vec3(1, 2, 3)
+    const v2 = new Vec3(-1, 0, 1)
+    const v3 = v1.plus(v2)
     assert.strictEqual(v1.x, 1)
     assert.strictEqual(v1.y, 2)
     assert.strictEqual(v1.z, 3)
@@ -98,9 +151,9 @@ describe('vec3', function () {
     assert.strictEqual(v3.z, 4)
   })
   it('minus', function () {
-    var v1 = new Vec3(1, 2, 3)
-    var v2 = new Vec3(-1, 0, 1)
-    var v3 = v1.minus(v2)
+    const v1 = new Vec3(1, 2, 3)
+    const v2 = new Vec3(-1, 0, 1)
+    const v3 = v1.minus(v2)
     assert.strictEqual(v1.x, 1)
     assert.strictEqual(v1.y, 2)
     assert.strictEqual(v1.z, 3)
@@ -112,8 +165,8 @@ describe('vec3', function () {
     assert.strictEqual(v3.z, 2)
   })
   it('scaled', function () {
-    var v1 = new Vec3(1, 2, 3)
-    var v2 = v1.scaled(2)
+    const v1 = new Vec3(1, 2, 3)
+    const v2 = v1.scaled(2)
     assert.strictEqual(v1.x, 1)
     assert.strictEqual(v1.y, 2)
     assert.strictEqual(v1.z, 3)
@@ -122,44 +175,48 @@ describe('vec3', function () {
     assert.strictEqual(v2.z, 6)
   })
   it('abs', function () {
-    var v1 = new Vec3(1.1, -1.5, 1.9)
-    var v2 = v1.abs()
+    const v1 = new Vec3(1.1, -1.5, 1.9)
+    const v2 = v1.abs()
     v1.x = 10
     assert.strictEqual(v2.x, 1.1)
     assert.strictEqual(v2.y, 1.5)
     assert.strictEqual(v2.z, 1.9)
   })
   it('distanceTo', function () {
-    var v1 = new Vec3(1, 1, 1)
-    var v2 = new Vec3(2, 2, 2)
-    var dist1 = v1.distanceTo(v2)
-    var dist2 = v2.distanceTo(v1)
-    var expected = 1.7320508075688772
+    const v1 = new Vec3(1, 1, 1)
+    const v2 = new Vec3(2, 2, 2)
+    const dist1 = v1.distanceTo(v2)
+    const dist2 = v2.distanceTo(v1)
+    const expected = 1.7320508075688772
     assert.strictEqual(dist1, dist2)
     assert.strictEqual(Math.round(dist1 * 100000), Math.round(expected * 100000))
   })
   it('distanceSquared', function () {
-    var v1 = new Vec3(1, 1, 1)
-    var v2 = new Vec3(2, 2, 2)
-    var dist1 = v1.distanceSquared(v2)
-    var dist2 = v2.distanceSquared(v1)
-    var expected = 3
+    const v1 = new Vec3(1, 1, 1)
+    const v2 = new Vec3(2, 2, 2)
+    const dist1 = v1.distanceSquared(v2)
+    const dist2 = v2.distanceSquared(v1)
+    const expected = 3
     assert.strictEqual(dist1, dist2)
     assert.strictEqual(Math.round(dist1 * 100000), Math.round(expected * 100000))
   })
   it('equals', function () {
-    var v1 = new Vec3(1, 2, 3)
-    var v2 = v1.scaled(0.23424)
-    var v3 = v1.scaled(0.23424)
+    const v1 = new Vec3(1, 2, 3)
+    const v2 = v1.scaled(0.23424)
+    const v3 = v1.scaled(0.23424)
     assert.ok(v2.equals(v3))
+    const v4 = new Vec3(0.1, 0, 0)
+    const v5 = new Vec3(0.2, 0, 0)
+    const v6 = new Vec3(0.3, 0, 0)
+    assert.ok(v4.plus(v5).equals(v6, Number.EPSILON))
   })
   it('toString', function () {
-    var v1 = new Vec3(1, -1, 3.14)
+    const v1 = new Vec3(1, -1, 3.14)
     assert.strictEqual(v1.toString(), '(1, -1, 3.14)')
   })
   it('clone', function () {
-    var v1 = new Vec3(1, 2, 3)
-    var v2 = v1.clone()
+    const v1 = new Vec3(1, 2, 3)
+    const v2 = v1.clone()
     v2.x = 10
     assert.strictEqual(v1.x, 1)
     assert.strictEqual(v1.y, 2)
@@ -169,35 +226,53 @@ describe('vec3', function () {
     assert.strictEqual(v2.z, 3)
   })
   it('add', function () {
-    var v1 = new Vec3(1, 2, 3)
-    var v2 = new Vec3(-1, -2, -3)
-    var v3 = v1.add(v2)
+    const v1 = new Vec3(1, 2, 3)
+    const v2 = new Vec3(-1, -2, -3)
+    const v3 = v1.add(v2)
     assert.strictEqual(v3, v1)
     assert.strictEqual(v1.x, 0)
     assert.strictEqual(v1.y, 0)
     assert.strictEqual(v1.z, 0)
   })
   it('subtract', function () {
-    var v1 = new Vec3(1, 2, 3)
-    var v2 = new Vec3(-1, -2, -3)
-    var v3 = v1.subtract(v2)
+    const v1 = new Vec3(1, 2, 3)
+    const v2 = new Vec3(-1, -2, -3)
+    const v3 = v1.subtract(v2)
     assert.strictEqual(v3, v1)
     assert.strictEqual(v1.x, 2)
     assert.strictEqual(v1.y, 4)
     assert.strictEqual(v1.z, 6)
   })
+  it('multiply', function () {
+    const v1 = new Vec3(1, 2, 3)
+    const v2 = new Vec3(-1, -2, -5)
+    const v3 = v1.multiply(v2)
+    assert.strictEqual(v3, v1)
+    assert.strictEqual(v1.x, -1)
+    assert.strictEqual(v1.y, -4)
+    assert.strictEqual(v1.z, -15)
+  })
+  it('divide', function () {
+    const v1 = new Vec3(10, 20, 30)
+    const v2 = new Vec3(2, 5, 3)
+    const v3 = v1.divide(v2)
+    assert.strictEqual(v3, v1)
+    assert.strictEqual(v1.x, 5)
+    assert.strictEqual(v1.y, 4)
+    assert.strictEqual(v1.z, 10)
+  })
   it('set', function () {
-    var v1 = new Vec3(12, 32, 46)
-    var v2 = v1.set(0, 10, 100)
+    const v1 = new Vec3(12, 32, 46)
+    const v2 = v1.set(0, 10, 100)
     assert.strictEqual(v1, v2)
     assert.strictEqual(v1.x, 0)
     assert.strictEqual(v1.y, 10)
     assert.strictEqual(v1.z, 100)
   })
   it('modulus', function () {
-    var v1 = new Vec3(12, 32, -1)
-    var v2 = new Vec3(14, 32, 16)
-    var v3 = v1.modulus(v2)
+    const v1 = new Vec3(12, 32, -1)
+    const v2 = new Vec3(14, 32, 16)
+    const v3 = v1.modulus(v2)
     assert.strictEqual(v1.x, 12)
     assert.strictEqual(v1.y, 32)
     assert.strictEqual(v1.z, -1)
@@ -209,29 +284,29 @@ describe('vec3', function () {
     assert.strictEqual(v3.z, 15)
   })
   it('volume', function () {
-    var v1 = new Vec3(3, 4, 5)
+    const v1 = new Vec3(3, 4, 5)
     assert.strictEqual(v1.volume(), 60)
   })
   it('min', function () {
-    var v1 = new Vec3(-1, 0, 1)
-    var v2 = new Vec3(10, -10, 1.1)
-    var v3 = v1.min(v2)
+    const v1 = new Vec3(-1, 0, 1)
+    const v2 = new Vec3(10, -10, 1.1)
+    const v3 = v1.min(v2)
     assert.strictEqual(v3.x, -1)
     assert.strictEqual(v3.y, -10)
     assert.strictEqual(v3.z, 1)
   })
   it('max', function () {
-    var v1 = new Vec3(-1, 0, 1)
-    var v2 = new Vec3(10, -10, 1.1)
-    var v3 = v1.max(v2)
+    const v1 = new Vec3(-1, 0, 1)
+    const v2 = new Vec3(10, -10, 1.1)
+    const v3 = v1.max(v2)
     assert.strictEqual(v3.x, 10)
     assert.strictEqual(v3.y, 0)
     assert.strictEqual(v3.z, 1.1)
   })
   it('update', function () {
-    var v1 = new Vec3(-1, 0, 1)
-    var v2 = new Vec3(10, -10, 1.1)
-    var v3 = v1.update(v2)
+    const v1 = new Vec3(-1, 0, 1)
+    const v2 = new Vec3(10, -10, 1.1)
+    const v3 = v1.update(v2)
     assert.strictEqual(v3, v1)
     assert.strictEqual(v1.x, 10)
     assert.strictEqual(v1.y, -10)
@@ -241,97 +316,97 @@ describe('vec3', function () {
     assert.strictEqual(v2.z, 1.1)
   })
   it('norm', function () {
-    var v1 = new Vec3(-10, 0, 10)
-    assert.strictEqual(Math.round(v1.norm() * 100000), Math.round(14.142135623730950 * 100000))
+    const v1 = new Vec3(-10, 0, 10)
+    assert.strictEqual(Math.round(v1.norm() * 100000), Math.round(14.1421356237 * 100000))
   })
   it('dot', function () {
-    var v1 = new Vec3(-1, -1, -1)
-    var v2 = new Vec3(1, 1, 1)
+    const v1 = new Vec3(-1, -1, -1)
+    const v2 = new Vec3(1, 1, 1)
     assert.strictEqual(v1.dot(v2), -3)
   })
   it('cross', function () {
-    var v1 = new Vec3(1, 0, 0)
-    var v2 = new Vec3(0, 1, 0)
-    var v3 = new Vec3(0, 0, 1)
+    const v1 = new Vec3(1, 0, 0)
+    const v2 = new Vec3(0, 1, 0)
+    const v3 = new Vec3(0, 0, 1)
     assert.ok(v1.cross(v2).equals(v3))
   })
   it('unit', function () {
-    var v1 = new Vec3(10, -10, 1.1)
-    var v2 = v1.unit()
-    assert.strictEqual(Math.round(v2.x * 100000), Math.round(0.7049774402016568 * 100000))
-    assert.strictEqual(Math.round(v2.y * 100000), Math.round(-0.704977440201656 * 100000))
-    assert.strictEqual(Math.round(v2.z * 100000), Math.round(0.07754751842218225 * 100000))
-    var v3 = new Vec3(0, 0, 0)
-    var v4 = v3.unit()
+    const v1 = new Vec3(10, -10, 1.1)
+    const v2 = v1.unit()
+    assert.strictEqual(Math.round(v2.x * 100000), Math.round(0.70497744020 * 100000))
+    assert.strictEqual(Math.round(v2.y * 100000), Math.round(-0.7049774402 * 100000))
+    assert.strictEqual(Math.round(v2.z * 100000), Math.round(0.07754751842 * 100000))
+    const v3 = new Vec3(0, 0, 0)
+    const v4 = v3.unit()
     assert.strictEqual(v4.x, 0)
     assert.strictEqual(v4.y, 0)
     assert.strictEqual(v4.z, 0)
   })
   it('normalize', function () {
-    var v1 = new Vec3(10, -10, 1.1)
-    var v2 = v1.normalize()
-    assert.strictEqual(Math.round(v2.x * 100000), Math.round(0.7049774402016568 * 100000))
-    assert.strictEqual(Math.round(v2.y * 100000), Math.round(-0.704977440201656 * 100000))
-    assert.strictEqual(Math.round(v2.z * 100000), Math.round(0.07754751842218225 * 100000))
-    var v3 = new Vec3(0, 0, 0)
-    var v4 = v3.normalize()
+    const v1 = new Vec3(10, -10, 1.1)
+    const v2 = v1.normalize()
+    assert.strictEqual(Math.round(v2.x * 100000), Math.round(0.70497744020 * 100000))
+    assert.strictEqual(Math.round(v2.y * 100000), Math.round(-0.7049774402 * 100000))
+    assert.strictEqual(Math.round(v2.z * 100000), Math.round(0.07754751842 * 100000))
+    const v3 = new Vec3(0, 0, 0)
+    const v4 = v3.normalize()
     assert.strictEqual(v4.x, 0)
     assert.strictEqual(v4.y, 0)
     assert.strictEqual(v4.z, 0)
   })
   it('scale', function () {
-    var v1 = new Vec3(10, -10, 1.1)
-    var v2 = v1.scale(1.5)
+    const v1 = new Vec3(10, -10, 1.1)
+    const v2 = v1.scale(1.5)
     assert.strictEqual(v2.x, 15)
     assert.strictEqual(v2.y, -15)
     assert.strictEqual(Math.round(v2.z * 100000), Math.round(1.65 * 100000))
   })
   it('xyDistanceTo', function () {
-    var v1 = new Vec3(1, 1, 1)
-    var v2 = new Vec3(2, 2, 2)
-    var dist1 = v1.xyDistanceTo(v2)
-    var dist2 = v2.xyDistanceTo(v1)
-    var expected = 1.4142135623730950
+    const v1 = new Vec3(1, 1, 1)
+    const v2 = new Vec3(2, 2, 2)
+    const dist1 = v1.xyDistanceTo(v2)
+    const dist2 = v2.xyDistanceTo(v1)
+    const expected = 1.414213562
     assert.strictEqual(dist1, dist2)
     assert.strictEqual(Math.round(dist1 * 100000), Math.round(expected * 100000))
   })
   it('xzDistanceTo', function () {
-    var v1 = new Vec3(1, 1, 1)
-    var v2 = new Vec3(2, 2, 2)
-    var dist1 = v1.xzDistanceTo(v2)
-    var dist2 = v2.xzDistanceTo(v1)
-    var expected = 1.4142135623730950
+    const v1 = new Vec3(1, 1, 1)
+    const v2 = new Vec3(2, 2, 2)
+    const dist1 = v1.xzDistanceTo(v2)
+    const dist2 = v2.xzDistanceTo(v1)
+    const expected = 1.41421356237
     assert.strictEqual(dist1, dist2)
     assert.strictEqual(Math.round(dist1 * 100000), Math.round(expected * 100000))
   })
   it('yzDistanceTo', function () {
-    var v1 = new Vec3(1, 1, 1)
-    var v2 = new Vec3(2, 2, 2)
-    var dist1 = v1.yzDistanceTo(v2)
-    var dist2 = v2.yzDistanceTo(v1)
-    var expected = 1.4142135623730950
+    const v1 = new Vec3(1, 1, 1)
+    const v2 = new Vec3(2, 2, 2)
+    const dist1 = v1.yzDistanceTo(v2)
+    const dist2 = v2.yzDistanceTo(v1)
+    const expected = 1.41421356237
     assert.strictEqual(dist1, dist2)
     assert.strictEqual(Math.round(dist1 * 100000), Math.round(expected * 100000))
   })
   it('innerProduct', function () {
-    var v1 = new Vec3(-1, 0, 1)
-    var v2 = new Vec3(0, 1, 0)
-    var ip1 = v1.innerProduct(v2)
-    var ip2 = v2.innerProduct(v1)
+    const v1 = new Vec3(-1, 0, 1)
+    const v2 = new Vec3(0, 1, 0)
+    const ip1 = v1.innerProduct(v2)
+    const ip2 = v2.innerProduct(v1)
     assert.strictEqual(ip1, ip2)
     assert.strictEqual(ip1, 0)
   })
   it('manhattanDistanceTo', function () {
-    var v1 = new Vec3(-1, 0, 1)
-    var v2 = new Vec3(10, -10, 1.1)
-    var dist1 = v1.manhattanDistanceTo(v2)
-    var dist2 = v2.manhattanDistanceTo(v1)
+    const v1 = new Vec3(-1, 0, 1)
+    const v2 = new Vec3(10, -10, 1.1)
+    const dist1 = v1.manhattanDistanceTo(v2)
+    const dist2 = v2.manhattanDistanceTo(v1)
     assert.strictEqual(dist1, dist2)
     assert.strictEqual(dist1, 21.1)
   })
   it('toArray', function () {
-    var v1 = new Vec3(1, -1, 3.14)
-    var array = v1.toArray()
+    const v1 = new Vec3(1, -1, 3.14)
+    const array = v1.toArray()
     assert.strictEqual(v1.x, array[0])
     assert.strictEqual(v1.y, array[1])
     assert.strictEqual(v1.z, array[2])

package/wrapper.mjs

@@ -0,0 +1,4 @@
+import mod from './index.js'
+
+export default mod
+export const Vec3 = mod.Vec3