p5 2.3.0-rc.5 → 2.3.0

package/lib/p5.js

@@ -1,4 +1,4 @@
-/*! p5.js v2.3.0-rc.5 May 21, 2026 */
+/*! p5.js v2.3.0 May 28, 2026 */
 var p5 = (function () {
   'use strict';
 
@@ -15,7 +15,7 @@ var p5 = (function () {
    * @property {String} VERSION
    * @final
    */
-  const VERSION = '2.3.0-rc.5';
+  const VERSION = '2.3.0';
 
   // GRAPHICS RENDERER
   /**
@@ -19794,8 +19794,14 @@ var p5 = (function () {
    * This function is used by binary vector operations to prioritize shorter vectors,
    * and to emit a warning when lengths do not match.
    */
-  const prioritizeSmallerDimension = function(currentVectorDimension, args) {
-    return Math.min(currentVectorDimension, args.length);
+  const prioritizeSmallerDimension = function (currentVectorDimension, args) {
+    const resultDimension = Math.min(currentVectorDimension, args.length);
+    if (Array.isArray(args) && currentVectorDimension !== args.length) {
+      console.warn(
+        'When working with two vectors of different sizes, the smaller dimension is used. In this operation, both vector will be treated as ' + resultDimension + 'D vectors, and any additional values of the linger vector will be ignored.'
+      );
+    }
+    return resultDimension;
   };
 
   /**
@@ -20089,17 +20095,12 @@ var p5 = (function () {
     }
 
     /**
-     * Sets the vector's `x`, `y`, and `z` components.
+     * Sets the the vector to a new value.
      *
      * `set()` can use separate numbers, as in `v.set(1, 2, 3)`, a
      * <a href="#/p5.Vector">p5.Vector</a> object, as in `v.set(v2)`, or an
      * array of numbers, as in `v.set([1, 2, 3])`.
      *
-     * If a value isn't provided for a component, it will be set to 0. For
-     * example, `v.set(4, 5)` sets `v.x` to 4, `v.y` to 5, and `v.z` to 0.
-     * Calling `set()` with no arguments, as in `v.set()`, sets all the vector's
-     * components to 0.
-     *
      * @param {Number} [x] x component of the vector.
      * @param {Number} [y] y component of the vector.
      * @param {Number} [z] z component of the vector.
@@ -20184,8 +20185,6 @@ var p5 = (function () {
       }
     }
 
-
-
     /**
      * Adds to a vector's components.
      *
@@ -20193,11 +20192,10 @@ var p5 = (function () {
      * another <a href="#/p5.Vector">p5.Vector</a> object, as in `v.add(v2)`, or
      * an array of numbers, as in `v.add([1, 2, 3])`.
      *
-     * Add vectors only when they are the same size: both 2-dimensional, or
-     * both 3-dimensional. When two vectors of different sizes are added, the
-     * smaller dimension will be used, any additional values of the longer
-     * vector will be ignored.
-     * For example, adding `[1, 2, 3]` and `[4, 5]` will result in `[5, 7]`.
+     * You should add vectors only when they are the same size. When two vectors
+     * of different sizes are added, the smaller dimension will be used, any
+     * additional values of the longer vector will be ignored. For example,
+     * adding `[1, 2, 3]` and `[4, 5]` will result in `[5, 7]`.
      *
      * Calling `add()` with no arguments, as in `v.add()`, has no effect.
      *
@@ -20314,7 +20312,7 @@ var p5 = (function () {
      * @param  {p5.Vector|Number[]} value The vector to add
      * @chainable
      */
-    add(...args) {
+    add(args) {
       const minDimension = prioritizeSmallerDimension(this.dimensions, args);
       shrinkToDimension(this.values, minDimension);
 
@@ -20325,11 +20323,8 @@ var p5 = (function () {
       return this;
     }
 
-
-
     /**
-     * Performs modulo (remainder) division with a vector's `x`, `y`, and `z`
-     * components.
+     * Performs modulo (remainder) division with a vector's components.
      *
      * `rem()` can use separate numbers, as in `v.rem(1, 2, 3)`,
      * another <a href="#/p5.Vector">p5.Vector</a> object, as in `v.rem(v2)`, or
@@ -20339,8 +20334,8 @@ var p5 = (function () {
      * will be set to their values modulo 2. Calling `rem()` with no
      * arguments, as in `v.rem()`, has no effect.
      *
-     * Modulo vectors only when they are the same size: both 2D, or both 3D.
-     * When two vectors of different sizes are used, the smaller dimension will be
+     * You should modulo vectors only when they are the same size. When two
+     * vectors of different sizes are used, the smaller dimension will be
      * used, any additional values of the longer vector will be ignored.
      * For example, taking `[3, 6, 9]` modulo `[2, 4]` will result in `[1, 2]`.
      *
@@ -20438,13 +20433,20 @@ var p5 = (function () {
      * @param {p5.Vector | Number[]}  value  divisor vector.
      * @chainable
      */
-    rem(...args) {
+    rem(args) {
       const minDimension = prioritizeSmallerDimension(this.dimensions, args);
 
       shrinkToDimension(this.values, minDimension);
-      for (let i = 0; i < this.values.length; i++) {
-        if (args[i] > 0) {
-          this.values[i] = this.values[i] % args[i];
+
+      if(Array.isArray(args)){
+        for (let i = 0; i < this.values.length; i++) {
+          if (args[i] > 0) {
+            this.values[i] = this.values[i] % args[i];
+          }
+        }
+      } else if(args > 0) {
+        for (let i = 0; i < this.values.length; i++) {
+          this.values[i] = this.values[i] % args;
         }
       }
 
@@ -20452,7 +20454,7 @@ var p5 = (function () {
     }
 
     /**
-     * Subtracts from a vector's `x`, `y`, and `z` components.
+     * Subtracts from a vector's components.
      *
      * `sub()` can use separate numbers, as in `v.sub(1, 2, 3)`, another
      * <a href="#/p5.Vector">p5.Vector</a> object, as in `v.sub(v2)`, or an array
@@ -20460,8 +20462,8 @@ var p5 = (function () {
      *
      * Calling `sub()` with no arguments, as in `v.sub()`, has no effect.
      *
-     * Subtract vectors only when they are the same size: both 2D, or both 3D.
-     * When two vectors of different sizes are used, the smaller dimension will be
+     * You should subtract vectors only when they are the same size. When two
+     * vectors of different sizes are used, the smaller dimension will be
      * used, any additional values of the longer vector will be ignored.
      * For example, subtracting `[1, 2]` from `[3, 5, 7]` will result in `[2, 3]`.
      *
@@ -20573,7 +20575,7 @@ var p5 = (function () {
      * @param  {p5.Vector|Number[]} value the vector to subtract
      * @chainable
      */
-    sub(...args) {
+    sub(args) {
       const minDimension = prioritizeSmallerDimension(this.dimensions, args);
       shrinkToDimension(this.values, minDimension);
 
@@ -20585,7 +20587,7 @@ var p5 = (function () {
     }
 
     /**
-     * Multiplies a vector's `x`, `y`, and `z` components.
+     * Multiplies a vector's components.
      *
      * `mult()` can use separate numbers, as in `v.mult(1, 2, 3)`, another
      * <a href="#/p5.Vector">p5.Vector</a> object, as in `v.mult(v2)`, or an array
@@ -20595,8 +20597,8 @@ var p5 = (function () {
      * will be multiplied by 2. Calling `mult()` with no arguments, as in `v.mult()`, has
      * no effect.
      *
-     * Multiply vectors only when they are the same size: both 2D, or both 3D.
-     * When two vectors of different sizes are multiplied, the smaller dimension will be
+     * You should multiply vectors only when they are the same size. When two
+     * vectors of different sizes are multiplied, the smaller dimension will be
      * used, any additional values of the longer vector will be ignored.
      * For example, multiplying `[1, 2, 3]` by `[4, 5]` will result in `[4, 10]`.
      *
@@ -20761,19 +20763,25 @@ var p5 = (function () {
      * @param  {p5.Vector} v vector to multiply with the components of the original vector.
      * @chainable
      */
-    mult(...args) {
+    mult(args) {
       const minDimension = prioritizeSmallerDimension(this.dimensions, args);
       shrinkToDimension(this.values, minDimension);
 
-      for (let i = 0; i < this.values.length; i++) {
-        this.values[i] *= args[i];
+      if(Array.isArray(args)){
+        for (let i = 0; i < this.values.length; i++) {
+          this.values[i] *= args[i];
+        }
+      } else {
+        for (let i = 0; i < this.values.length; i++) {
+          this.values[i] *= args;
+        }
       }
 
       return this;
     }
 
     /**
-     * Divides a vector's `x`, `y`, and `z` components.
+     * Divides a vector's components.
      *
      * `div()` can use separate numbers, as in `v.div(1, 2, 3)`, another
      * <a href="#/p5.Vector">p5.Vector</a> object, as in `v.div(v2)`, or an array
@@ -20783,8 +20791,8 @@ var p5 = (function () {
      * will be divided by 2. Calling `div()` with no arguments, as in `v.div()`, has
      * no effect.
      *
-     * Divide vectors only when they are the same size: both 2D, or both 3D.
-     * When two vectors of different sizes are divided, the smaller dimension will be
+     * You should divide vectors only when they are the same size. When two
+     * vectors of different sizes are divided, the smaller dimension will be
      * used, any additional values of the longer vector will be ignored.
      * For example, dividing `[8, 12, 21]` by `[2, 3]` will result in `[4, 4]`.
      *
@@ -20950,24 +20958,41 @@ var p5 = (function () {
      * @param  {p5.Vector} v vector to divide the components of the original vector by.
      * @chainable
      */
-    div(...args) {
+    div(args) {
       const minDimension = prioritizeSmallerDimension(this.dimensions, args);
 
-      for (let i = 0; i < minDimension; i++) {
-        if (typeof args[i] !== 'number' || args[i] === 0) {
-          if (!this.friendlyErrorsDisabled()) {
-            console.warn(
-              'p5.Vector.prototype.div',
-              'Arguments contain components that are 0'
-            );
+      if (Array.isArray(args)) {
+        for (let i = 0; i < minDimension; i++) {
+          if ((typeof args[i] !== 'number' || args[i] === 0)) {
+            if (!this.friendlyErrorsDisabled()) {
+              console.warn(
+                'p5.Vector.prototype.div',
+                'Arguments contain components that are 0'
+              );
+            }
+            return this;
           }
-          return this;
         }
+      } else if(typeof args !== 'number' || args === 0) {
+        if (!this.friendlyErrorsDisabled()) {
+          console.warn(
+            'p5.Vector.prototype.div',
+            'Arguments contain components that are 0'
+          );
+        }
+        return this;
       }
 
       shrinkToDimension(this.values, minDimension);
-      for (let i = 0; i < this.values.length; i++) {
-        this.values[i] /= args[i];
+
+      if(Array.isArray(args)){
+        for (let i = 0; i < this.values.length; i++) {
+          this.values[i] /= args[i];
+        }
+      } else {
+        for (let i = 0; i < this.values.length; i++) {
+          this.values[i] /= args;
+        }
       }
 
       return this;
@@ -108361,7 +108386,7 @@ var p5 = (function () {
   function _defaultEmptyVector(target){
     return function(...args){
       if(args.length === 0){
-        this._friendlyError(
+        this.constructor._friendlyError(
           'In 1.x, createVector() was a shortcut for createVector(0, 0, 0). In 2.x, p5.js has vectors of any dimension, so you must provide your desired number of zeros. Use createVector(0, 0) for a 2D vector and createVector(0, 0, 0) for a 3D vector.',
           'p5.createVector'
         );
@@ -108382,7 +108407,7 @@ var p5 = (function () {
    */
   function _validatedVectorOperation(expectsSoloNumberArgument){
     return function(target){
-      return function(...args){
+      return function (...args) {
         if (args.length === 0) {
           // No arguments? No action
           return this;
@@ -108392,16 +108417,18 @@ var p5 = (function () {
         } else if (Array.isArray(args[0])) {
           // First argument is an array? Great, keep it!
           args = args[0];
-        } else if (expectsSoloNumberArgument && args.length === 1){
+        } else if (args.length === 1){
           // Special case for a solo numeric arguments only applies sometimes
-          args = new Array(3).fill(args[0]);
+          if (expectsSoloNumberArgument) {
+            args = args[0];
+          }
         }
 
-        if (Array.isArray(args)) {
+        if(Array.isArray(args)){
           for (let i = 0; i < args.length; i++) {
             const v = args[i];
             if (typeof v !== 'number' || !Number.isFinite(v)) {
-              if (!Vector.friendlyErrorsDisabled()) {
+              if (!this.friendlyErrorsDisabled()) {
                 this._friendlyError(
                   'Arguments contain non-finite numbers',
                   'p5.Vector'
@@ -108410,9 +108437,19 @@ var p5 = (function () {
               return this;
             }
           }
+        } else {
+          if (typeof args !== 'number' || !Number.isFinite(args)) {
+            if (!this.friendlyErrorsDisabled()) {
+              this._friendlyError(
+                'Arguments contain non-finite numbers',
+                'p5.Vector'
+              );
+            }
+            return this;
+          }
         }
 
-        return target.call(this, ...args);
+        return target.call(this, args);
       };
     };
   }