@litecanvas/utils 0.12.0 → 0.13.0

package/dist/vector.js

@@ -15,29 +15,39 @@
     UP: () => UP,
     Vector: () => Vector,
     ZERO: () => ZERO,
-    isvector: () => isvector,
     vec: () => vec,
-    vecadd: () => vecadd,
-    vecconfig: () => vecconfig,
-    veccopy: () => veccopy,
-    veccross: () => veccross,
-    vecdir: () => vecdir,
-    vecdist: () => vecdist,
-    vecdist2: () => vecdist2,
-    vecdiv: () => vecdiv,
-    vecdot: () => vecdot,
-    veceq: () => veceq,
-    veclerp: () => veclerp,
-    veclimit: () => veclimit,
-    vecmag: () => vecmag,
-    vecmag2: () => vecmag2,
-    vecmult: () => vecmult,
-    vecnorm: () => vecnorm,
-    vecrand: () => vecrand,
-    vecrot: () => vecrot,
-    vecset: () => vecset,
-    vecsub: () => vecsub
+    vecAbs: () => vecAbs,
+    vecAdd: () => vecAdd,
+    vecAngle: () => vecAngle,
+    vecCeil: () => vecCeil,
+    vecClamp: () => vecClamp,
+    vecCross: () => vecCross,
+    vecDist: () => vecDist,
+    vecDist2: () => vecDist2,
+    vecDiv: () => vecDiv,
+    vecDot: () => vecDot,
+    vecEq: () => vecEq,
+    vecFloor: () => vecFloor,
+    vecIsZero: () => vecIsZero,
+    vecLerp: () => vecLerp,
+    vecLimit: () => vecLimit,
+    vecMag: () => vecMag,
+    vecMag2: () => vecMag2,
+    vecMove: () => vecMove,
+    vecMult: () => vecMult,
+    vecNorm: () => vecNorm,
+    vecRand: () => vecRand,
+    vecReflect: () => vecReflect,
+    vecRotate: () => vecRotate,
+    vecRound: () => vecRound,
+    vecSet: () => vecSet,
+    vecSetMag: () => vecSetMag,
+    vecSub: () => vecSub
   });
+  var sqrt = Math.sqrt;
+  var cos = Math.cos;
+  var sin = Math.sin;
+  var PI2 = 2 * Math.PI;
   var Vector = class {
     /** @type {number} */
     x;
@@ -58,102 +68,145 @@
       return `Vector (${this.x}, ${this.y})`;
     }
   };
-  var vec = (x = 0, y = x) => new Vector(x, y);
-  var veceq = (v, x, y = x) => {
-    if (isvector(x)) {
-      return veceq(v, x.x, x.y);
+  var isVector = (v) => v instanceof Vector;
+  var vec = (x = 0, y = x) => {
+    if (isVector(x)) {
+      y = x.y;
+      x = x.x;
+    }
+    return new Vector(x, y);
+  };
+  var vecEq = (v, x, y = x) => {
+    if (isVector(x)) {
+      return vecEq(v, x.x, x.y);
     }
     return v.x === x && v.y === y;
   };
-  var veccopy = (v) => vec(v.x, v.y);
-  var vecset = (v, x, y = x) => {
-    if (isvector(x)) {
-      vecset(v, x.x, x.y);
+  var vecSet = (v, x, y = x) => {
+    if (isVector(x)) {
+      vecSet(v, x.x, x.y);
     } else {
       v.x = x;
       v.y = y;
     }
+    return v;
   };
-  var vecadd = (v, x, y = x) => {
-    if (isvector(x)) {
-      vecadd(v, x.x, x.y);
-    } else {
-      v.x += x;
-      v.y += y;
+  var vecAdd = (v, x, y = x) => {
+    if (isVector(x)) {
+      return vecAdd(v, x.x, x.y);
     }
+    v.x += x;
+    v.y += y;
+    return v;
   };
-  var vecsub = (v, x, y = x) => {
-    if (isvector(x)) {
-      vecsub(v, x.x, x.y);
-    } else {
-      v.x -= x;
-      v.y -= y;
+  var vecSub = (v, x, y = x) => {
+    if (isVector(x)) {
+      return vecSub(v, x.x, x.y);
     }
+    v.x -= x;
+    v.y -= y;
+    return v;
   };
-  var vecmult = (v, x, y = x) => {
-    if (isvector(x)) {
-      vecmult(v, x.x, x.y);
-    } else {
-      v.x *= x;
-      v.y *= y;
+  var vecMult = (v, x, y = x) => {
+    if (isVector(x)) {
+      return vecMult(v, x.x, x.y);
     }
+    v.x *= x;
+    v.y *= y;
+    return v;
   };
-  var vecdiv = (v, x, y = x) => {
-    if (isvector(x)) {
-      vecdiv(v, x.x, x.y);
-    } else {
-      v.x /= x;
-      v.y /= y;
+  var vecDiv = (v, x, y = x) => {
+    if (isVector(x)) {
+      return vecDiv(v, x.x, x.y);
     }
-  };
-  var vecrot = (v, radians) => {
-    const cos = Math.cos(radians), sin = Math.sin(radians);
-    v.x = cos * v.x - sin * v.y;
-    v.y = sin * v.x + cos * v.y;
-  };
-  var vecmag = (v) => Math.sqrt(v.x * v.x + v.y * v.y);
-  var vecmag2 = (v) => v.x * v.x + v.y * v.y;
-  var vecnorm = (v) => {
-    const length = vecmag(v);
+    v.x /= x;
+    v.y /= y;
+    return v;
+  };
+  var vecRotate = (v, radians) => {
+    const c = cos(radians), s = sin(radians);
+    v.x = c * v.x - s * v.y;
+    v.y = s * v.x + c * v.y;
+    return v;
+  };
+  var vecReflect = (v, normal) => {
+    const normalCopy = vecNorm(vec(normal));
+    return vecSub(v, vecMult(normalCopy, 2 * vecDot(v, normalCopy)));
+  };
+  var vecSetMag = (v, value) => {
+    vecNorm(v);
+    vecMult(v, value);
+    return v;
+  };
+  var vecMag = (v) => sqrt(v.x * v.x + v.y * v.y);
+  var vecMag2 = (v) => v.x * v.x + v.y * v.y;
+  var vecNorm = (v) => {
+    const length = vecMag(v);
     if (length > 0) {
-      vecdiv(v, length);
+      vecDiv(v, length);
     }
+    return v;
   };
-  var veclimit = (v, max) => {
-    const sq = vecmag2(v);
+  var vecLimit = (v, max = 1) => {
+    const sq = vecMag2(v);
     if (sq > max * max) {
-      vecdiv(v, Math.sqrt(sq));
-      vecmult(v, max);
+      vecDiv(v, sqrt(sq));
+      vecMult(v, max);
     }
+    return v;
   };
-  var vecdist = (a, b) => {
+  var vecDist = (a, b) => {
     const dx = a.x - b.x;
     const dy = a.y - b.y;
-    return Math.sqrt(dx * dx + dy * dy);
+    return sqrt(dx * dx + dy * dy);
   };
-  var vecdist2 = (a, b) => {
+  var vecDist2 = (a, b) => {
     const dx = a.x - b.x;
     const dy = a.y - b.y;
     return dx * dx + dy * dy;
   };
-  var vecdir = (v) => Math.atan2(v.y, v.x);
-  var vecdot = (a, b) => a.x * b.x + a.y * b.y;
-  var veccross = (a, b) => a.x * b.y - a.y * b.x;
-  var veclerp = (a, b, t) => {
+  var vecAngle = (v) => Math.atan2(v.y, v.x);
+  var vecDot = (a, b) => a.x * b.x + a.y * b.y;
+  var vecCross = (a, b) => a.x * b.y - a.y * b.x;
+  var vecLerp = (a, b, t) => {
     a.x += (b.x - a.x) * t || 0;
     a.y += (b.y - a.y) * t || 0;
-  };
-  var vecrand = (minlength = 1, maxlength = minlength) => {
-    const angle = vecconfig.random() * 2 * Math.PI;
-    const radius = vecconfig.random() * (maxlength - minlength) + minlength;
-    return vec(Math.cos(angle) * radius, Math.sin(angle) * radius);
-  };
-  var isvector = (v) => v instanceof Vector;
-  var vecconfig = {
-    random: () => {
-      return globalThis.rand ? rand() : Math.random();
-    }
-  };
+    return a;
+  };
+  var vecRand = (minlength = 1, maxlength = minlength, randomFn = globalThis.rand || Math.random) => {
+    const angle = randomFn() * PI2;
+    const radius = randomFn() * (maxlength - minlength) + minlength;
+    return vec(cos(angle) * radius, sin(angle) * radius);
+  };
+  var vecAbs = (v) => {
+    v.x = Math.abs(v.x);
+    v.y = Math.abs(v.y);
+    return v;
+  };
+  var vecCeil = (v) => {
+    v.x = Math.ceil(v.x);
+    v.y = Math.ceil(v.y);
+    return v;
+  };
+  var vecFloor = (v) => {
+    v.x = Math.floor(v.x);
+    v.y = Math.floor(v.y);
+    return v;
+  };
+  var vecRound = (v) => {
+    v.x = Math.round(v.x);
+    v.y = Math.round(v.y);
+    return v;
+  };
+  var vecClamp = (v, min, max) => {
+    if (v.x < min.x) v.x = min.x;
+    if (v.x > max.x) v.x = max.x;
+    if (v.y < min.y) v.y = min.y;
+    if (v.y > max.y) v.y = max.y;
+    return v;
+  };
+  var vecMove = (v, to, delta = 1) => vecAdd(v, to.x * delta, to.y * delta);
+  var vecIsZero = (v) => vecEq(v, ZERO);
   var ZERO = /* @__PURE__ */ vec(0, 0);
   var ONE = /* @__PURE__ */ vec(1, 1);
   var UP = /* @__PURE__ */ vec(0, -1);

package/dist/vector.min.js

@@ -1 +1 @@
-(()=>{var M=Object.defineProperty;var g=(t,o)=>{for(var s in o)M(t,s,{get:o[s],enumerable:!0})};var i={};g(i,{DOWN:()=>G,LEFT:()=>H,ONE:()=>w,RIGHT:()=>F,UP:()=>D,Vector:()=>n,ZERO:()=>j,isvector:()=>r,vec:()=>c,vecadd:()=>l,vecconfig:()=>y,veccopy:()=>m,veccross:()=>R,vecdir:()=>N,vecdist:()=>E,vecdist2:()=>I,vecdiv:()=>x,vecdot:()=>P,veceq:()=>a,veclerp:()=>U,veclimit:()=>O,vecmag:()=>u,vecmag2:()=>f,vecmult:()=>p,vecnorm:()=>T,vecrand:()=>$,vecrot:()=>q,vecset:()=>d,vecsub:()=>h});var n=class{x;y;constructor(o=0,s=o){this.x=o,this.y=s}toString(){return`Vector (${this.x}, ${this.y})`}},c=(t=0,o=t)=>new n(t,o),a=(t,o,s=o)=>r(o)?a(t,o.x,o.y):t.x===o&&t.y===s,m=t=>c(t.x,t.y),d=(t,o,s=o)=>{r(o)?d(t,o.x,o.y):(t.x=o,t.y=s)},l=(t,o,s=o)=>{r(o)?l(t,o.x,o.y):(t.x+=o,t.y+=s)},h=(t,o,s=o)=>{r(o)?h(t,o.x,o.y):(t.x-=o,t.y-=s)},p=(t,o,s=o)=>{r(o)?p(t,o.x,o.y):(t.x*=o,t.y*=s)},x=(t,o,s=o)=>{r(o)?x(t,o.x,o.y):(t.x/=o,t.y/=s)},q=(t,o)=>{let s=Math.cos(o),e=Math.sin(o);t.x=s*t.x-e*t.y,t.y=e*t.x+s*t.y},u=t=>Math.sqrt(t.x*t.x+t.y*t.y),f=t=>t.x*t.x+t.y*t.y,T=t=>{let o=u(t);o>0&&x(t,o)},O=(t,o)=>{let s=f(t);s>o*o&&(x(t,Math.sqrt(s)),p(t,o))},E=(t,o)=>{let s=t.x-o.x,e=t.y-o.y;return Math.sqrt(s*s+e*e)},I=(t,o)=>{let s=t.x-o.x,e=t.y-o.y;return s*s+e*e},N=t=>Math.atan2(t.y,t.x),P=(t,o)=>t.x*o.x+t.y*o.y,R=(t,o)=>t.x*o.y-t.y*o.x,U=(t,o,s)=>{t.x+=(o.x-t.x)*s||0,t.y+=(o.y-t.y)*s||0},$=(t=1,o=t)=>{let s=y.random()*2*Math.PI,e=y.random()*(o-t)+t;return c(Math.cos(s)*e,Math.sin(s)*e)},r=t=>t instanceof n,y={random:()=>globalThis.rand?rand():Math.random()},j=c(0,0),w=c(1,1),D=c(0,-1),F=c(1,0),G=c(0,1),H=c(-1,0);globalThis.utils=Object.assign(globalThis.utils||{},i);})();
+(()=>{var C=Object.defineProperty;var E=(t,o)=>{for(var r in o)C(t,r,{get:o[r],enumerable:!0})};var a={};E(a,{DOWN:()=>J,LEFT:()=>K,ONE:()=>k,RIGHT:()=>B,UP:()=>z,Vector:()=>s,ZERO:()=>q,vec:()=>c,vecAbs:()=>j,vecAdd:()=>i,vecAngle:()=>P,vecCeil:()=>w,vecClamp:()=>H,vecCross:()=>U,vecDist:()=>L,vecDist2:()=>N,vecDiv:()=>y,vecDot:()=>T,vecEq:()=>u,vecFloor:()=>F,vecIsZero:()=>W,vecLerp:()=>Z,vecLimit:()=>A,vecMag:()=>R,vecMag2:()=>D,vecMove:()=>V,vecMult:()=>x,vecNorm:()=>h,vecRand:()=>$,vecReflect:()=>S,vecRotate:()=>O,vecRound:()=>G,vecSet:()=>g,vecSetMag:()=>b,vecSub:()=>l});var p=Math.sqrt,f=Math.cos,d=Math.sin,I=2*Math.PI,s=class{x;y;constructor(o=0,r=o){this.x=o,this.y=r}toString(){return`Vector (${this.x}, ${this.y})`}},n=t=>t instanceof s,c=(t=0,o=t)=>(n(t)&&(o=t.y,t=t.x),new s(t,o)),u=(t,o,r=o)=>n(o)?u(t,o.x,o.y):t.x===o&&t.y===r,g=(t,o,r=o)=>(n(o)?g(t,o.x,o.y):(t.x=o,t.y=r),t),i=(t,o,r=o)=>n(o)?i(t,o.x,o.y):(t.x+=o,t.y+=r,t),l=(t,o,r=o)=>n(o)?l(t,o.x,o.y):(t.x-=o,t.y-=r,t),x=(t,o,r=o)=>n(o)?x(t,o.x,o.y):(t.x*=o,t.y*=r,t),y=(t,o,r=o)=>n(o)?y(t,o.x,o.y):(t.x/=o,t.y/=r,t),O=(t,o)=>{let r=f(o),e=d(o);return t.x=r*t.x-e*t.y,t.y=e*t.x+r*t.y,t},S=(t,o)=>{let r=h(c(o));return l(t,x(r,2*T(t,r)))},b=(t,o)=>(h(t),x(t,o),t),R=t=>p(t.x*t.x+t.y*t.y),D=t=>t.x*t.x+t.y*t.y,h=t=>{let o=R(t);return o>0&&y(t,o),t},A=(t,o=1)=>{let r=D(t);return r>o*o&&(y(t,p(r)),x(t,o)),t},L=(t,o)=>{let r=t.x-o.x,e=t.y-o.y;return p(r*r+e*e)},N=(t,o)=>{let r=t.x-o.x,e=t.y-o.y;return r*r+e*e},P=t=>Math.atan2(t.y,t.x),T=(t,o)=>t.x*o.x+t.y*o.y,U=(t,o)=>t.x*o.y-t.y*o.x,Z=(t,o,r)=>(t.x+=(o.x-t.x)*r||0,t.y+=(o.y-t.y)*r||0,t),$=(t=1,o=t,r=globalThis.rand||Math.random)=>{let e=r()*I,M=r()*(o-t)+t;return c(f(e)*M,d(e)*M)},j=t=>(t.x=Math.abs(t.x),t.y=Math.abs(t.y),t),w=t=>(t.x=Math.ceil(t.x),t.y=Math.ceil(t.y),t),F=t=>(t.x=Math.floor(t.x),t.y=Math.floor(t.y),t),G=t=>(t.x=Math.round(t.x),t.y=Math.round(t.y),t),H=(t,o,r)=>(t.x<o.x&&(t.x=o.x),t.x>r.x&&(t.x=r.x),t.y<o.y&&(t.y=o.y),t.y>r.y&&(t.y=r.y),t),V=(t,o,r=1)=>i(t,o.x*r,o.y*r),W=t=>u(t,q),q=c(0,0),k=c(1,1),z=c(0,-1),B=c(1,0),J=c(0,1),K=c(-1,0);globalThis.utils=Object.assign(globalThis.utils||{},a);})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@litecanvas/utils",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Utilities to help build litecanvas games",
   "author": "Luiz Bills <luizbills@pm.me>",
   "license": "MIT",

package/src/actor/index.js

@@ -1,4 +1,4 @@
-import { Vector, vec, veccopy } from "../vector/index.js"
+import { Vector, vec } from "../vector/index.js"
 import "litecanvas"
 
 export const ANCHOR_CENTER = vec(0.5, 0.5)
@@ -37,7 +37,7 @@ export class Actor {
   constructor(sprite, position, anchor = ANCHOR_TOP_LEFT) {
     this.sprite = sprite
     this.pos = position || vec(0)
-    this._o = veccopy(anchor)
+    this._o = vec(anchor) // clone the anchor vector
     this._s = vec(1, 1)
   }
 
@@ -98,6 +98,13 @@ export class Actor {
     return this.sprite.height * this._s.y
   }
 
+  /**
+   * @retuns {Vector}
+   */
+  get scale() {
+    return this._s
+  }
+
   /**
    * @returns {number[]}
    */
@@ -109,13 +116,6 @@ export class Actor {
     return [x, y, w, h]
   }
 
-  /**
-   * @retuns {Vector}
-   */
-  get scale() {
-    return this._s
-  }
-
   /**
    * Update the transformation matrix, sets the opacity and draw the actor sprite image.
    *

package/src/math/README.md

@@ -61,3 +61,18 @@ function draw() {
   circfill(CENTERX, CENTERY + y, 50, 4)
 }
 ```
+
+## range
+
+Returns a sequence of numbers from `0` to `size - 1`.
+
+Syntax: `range(size: number): number[]`
+
+```js
+import { range } from "@litecanvas/utils"
+
+// prints 0 1 2 3 4
+for (let i of range(5)) {
+  console.log(i)
+}
+```

package/src/math/range.js

@@ -1,10 +1,10 @@
 /**
- * Returns a sequence of numbers from 0 to n-1.
+ * Returns a sequence of numbers from `0` to `size - 1`.
  *
- * @param {number} n the amount of numbers
+ * @param {number} size the amount of numbers
  * @returns {number[]}
  * @example
- *    // print 0 1 2 3 4 5
+ *    // print 0 1 2 3 4
  *    for(let i of range(5)) console.log(i)
  */
-export default (n) => Array.from(Array(n).keys())
+export default (size) => Array.from(Array(size).keys())

package/src/vector/README.md

@@ -6,9 +6,9 @@ A class to describe a two-dimensional vector.
 
 ## vec
 
-Creates a vector.
+Copy a vector or create a new one.
 
-Syntax: `vec(x: number = 0, y: number = 0): Vector`
+Syntax to create: `vec(x: number = 0, y: number = 0): Vector`
 
 ```js
 import { vec, Vector } from "@litecanvas/utils"
@@ -20,18 +20,14 @@ console.log(position.x) // outputs 50
 console.log(position.y) // outputs 25
 ```
 
-## veccopy
-
-Creates a copy/clone of a given vector.
-
-Syntax: `veccopy(v: Vector): Vector`
+Syntax to copy: `vec(other: Vector): Vector`
 
 ```js
-import { vec, veccopy } from "@litecanvas/utils"
+import { vec } from "@litecanvas/utils"
 
 const a = vec(1, 1)
 const b = a // `b`` is a references of `a`
-const c = veccopy(a) // `c` is a copy of `a`
+const c = vec(a) // `c` is a copy of `a`
 
 c.x = 99 // this changes only `c`
 b.x = 0 // this changes `a` and `b`
@@ -41,145 +37,136 @@ console.log(b) // outputs "Vector (0, 1)
 console.log(c) // outputs "Vector (99, 1)
 ```
 
-## vecset
+## vecSet
 
-Assigns new values to a vector.
+Assigns new values to a vector and returns the vector (first argument).
 
-Syntax: `vecset(v: Vector, x: number, y: number = x): void`
+Syntax: `vecSet(v: Vector, x: number, y: number = x): Vector`
 
 ```js
-import { vec, vecset } from "@litecanvas/utils"
+import { vec, vecSet } from "@litecanvas/utils"
 
 const a = vec(0, 0)
-vecset(a, 10, 20)
+vecSet(a, 10, 20)
 
 console.log(a.x) // outputs 10
 console.log(a.y) // outputs 20
 ```
 
-## vecadd
+## vecAdd
 
-Add values to a vector.
+Add values to a vector and returns the vector (first argument).
 
-Syntax: `vecadd(v: Vector, x: number, y: number = x): void`
+Syntax: `vecAdd(v: Vector, x: number, y: number = x): Vector`
 
 ```js
-import { vec, vecadd } from "@litecanvas/utils"
+import { vec, vecAdd } from "@litecanvas/utils"
 
 const a = vec(10, 10)
-vecadd(a, 5, 20)
+vecAdd(a, 50, 90)
 
-console.log(a.x) // outputs 15
-console.log(a.y) // outputs 30
+console.log(a.x) // outputs 60
+console.log(a.y) // outputs 100
 ```
 
-## vecsub
+## vecSub
 
-Subtracts values from to a vector.
+Subtracts values from to a vector and returns the vector (first argument).
 
-Syntax: `vecsub(v: Vector, x: number, y: number = x): void`
+Syntax: `vecSub(v: Vector, x: number, y: number = x): Vector`
 
-## vecmult
+## vecMult
 
-Multiplies (scale) a vector.
+Multiplies (scale) a vector and returns the vector (first argument).
 
-Syntax: `vecmult(v: Vector, x: number, y: number = x): void`
+Syntax: `vecMult(v: Vector, x: number, y: number = x): Vector`
 
-## vecdiv
+## vecDiv
 
-Divides a vector.
+Divides a vector and returns the vector (first argument).
 
-Syntax: `vecdiv(v: Vector, x: number, y: number = x): void`
+Syntax: `vecdiv(v: Vector, x: number, y: number = x): Vector`
 
-## vecrot
+## vecRotate
 
-Rotates a vector by an angle (in radians) without changing its magnitude.
+Rotates a vector by an angle (in radians) without changing its magnitude and returns the vector (first argument).
 
-Syntax: `vecrot(v: Vector, radians: number): void`
+Syntax: `vecRotate(v: Vector, radians: number): Vector`
 
-## vecmag
+## vecMag
 
 Returns the magnitude (length) of the vector.
 
-Syntax: `vecmag(v: Vector): number`
+Syntax: `vecMag(v: Vector): number`
 
-## vecmag2
+## vecMag2
 
 Returns the magnitude (length) of the vector squared.
 
-Syntax: `vecmag2(v: Vector): number`
+Syntax: `vecMag2(v: Vector): number`
 
-## vecnorm
+## vecNorm
 
-Scales the values of a vector so that its magnitude is 1.
+Scales the values of a vector so that its magnitude is 1 and returns the vector (first argument).
 
-Syntax: `vecnorm(v: Vector): void`
+Syntax: `vecNorm(v: Vector): Vector`
 
-## veclimit
+## vecLimit
 
-Limits (clamp) a vector's magnitude to a maximum value.
+Limits (clamp) a vector's magnitude to a maximum value and returns the vector (first argument).
 
-Syntax: `veclimit(v: Vector, max: number): void`
+Syntax: `vecLimit(v: Vector, max: number): Vector`
 
-## vecdist
+## vecDist
 
 Returns the distance between two points represented by vectors.
 
-Syntax: `vecdist(a: Vector, b: Vector): number`
+Syntax: `vecDist(a: Vector, b: Vector): number`
 
-## vecdist2
+## vecDist2
 
 Returns the distance between two points represented by vectors squared.
 
-Syntax: `vecdist2(a: Vector, b: Vector): number`
+Syntax: `vecDist2(a: Vector, b: Vector): number`
 
-## vecdir
+## vecAngle
 
 Calculates the angle a vector makes with the positive x-axis.
 
-Syntax: `vecdir(v: Vector): number`
+Syntax: `vecAngle(v: Vector): number`
+
+```js
+const a = vecAngle(vec(1, 0)) // outputs 0 (zero)
+const b = vecAngle(vec(0, 1)) // outputs ~1.571 (same as Math.PI / 2)
+```
 
-## vecdot
+## vecDot
 
 Calculates the dot product of two vectors.
 
-Syntax: `vecdot(a: Vector, b: Vector): number`
+Syntax: `vecDot(a: Vector, b: Vector): number`
 
-## veccross
+## vecCross
 
 Calculates the dot product of two vectors.
 
-Syntax: `veccross(a: Vector, b: Vector): number`
+Syntax: `vecCross(a: Vector, b: Vector): number`
 
-## veclerp
+## vecLerp
+
+Calculates new vector values that are proportionally the same distance
+between two vectors and returns the first vector (first argument).
 
-Calculates new vector values that are proportionally the same distance between two vectors.
 The `atm` parameter is the amount to interpolate between the old vector and the new vector:
 `0.0` keeps all values equal to the old vector's, `0.5` is halfway between, and `1.0` sets all
 values equal to the new vector's.
 
-Syntax: `veclerp(a: Vector, b: Vector, atm: number): void`
+Syntax: `vecLerp(a: Vector, b: Vector, atm: number): Lerp`
 
-## vecrand
+## vecRand
 
 Creates a vector with random direction and (optional) length.
 
-If the `litecanvas#rand()` not is globally explosed, uses `Math.random()`.
-You can set `vecconfig.random` to set your own "random" function.
-
-Syntax: `vecrand(minlength: number = 1, maxlength: number = minlength): Vector`
+By default the `randomFn` (third argument) is the `globalThis.rand` (from litecanvas globally instantiated) or the native `Math.random`.
 
-```js
-import litecanvas from "litecanvas"
-import { vecrand, vecconfig } from "@litecanvas/utils"
-
-const engine = litecanvas({
-  loop: { init },
-})
-
-function init() {
-  // make sure to use the RNG of this litecanvas instance
-  vecconfig.random = engine.rand
-  v = vecrand()
-}
-```
+Syntax: `vecRand(minlength: number = 1, maxlength: number = minlength, randomFn?): Vector`