p5 2.3.0-rc.5 → 2.3.0

package/dist/webgl/p5.RendererGL.js

@@ -1,9 +1,9 @@
-import { ad as WEBGL, ab as WEBGL2, L as LIGHTEST, D as DARKEST, S as SUBTRACT, R as REPLACE, E as EXCLUSION, a as SCREEN, M as MULTIPLY, b as REMOVE, A as ADD, B as BLEND, c as TRIANGLES, n as CORNER, U as UNSIGNED_BYTE, g as LINEAR, aG as LINEAR_MIPMAP, a7 as TEXTURE, F as FLOAT, d as UNSIGNED_INT, H as HALF_FLOAT } from '../constants-CdA3y5zC.js';
-import { R as Renderer3D, o as readPixelWebGL, q as readPixelsWebGL, M as MipmapTexture, h as getWebGLShaderAttributes, g as getWebGLUniformMetadata, s as setWebGLUniformValue, e as setWebGLTextureParams, j as populateGLSLHooks, u as checkWebGLCapabilities } from '../rendering-mbOOQwHM.js';
+import { ad as WEBGL, ab as WEBGL2, L as LIGHTEST, D as DARKEST, S as SUBTRACT, R as REPLACE, E as EXCLUSION, a as SCREEN, M as MULTIPLY, b as REMOVE, A as ADD, B as BLEND, c as TRIANGLES, n as CORNER, U as UNSIGNED_BYTE, g as LINEAR, aG as LINEAR_MIPMAP, a7 as TEXTURE, F as FLOAT, d as UNSIGNED_INT, H as HALF_FLOAT } from '../constants-Dv6ZqA6s.js';
+import { R as Renderer3D, o as readPixelWebGL, q as readPixelsWebGL, M as MipmapTexture, h as getWebGLShaderAttributes, g as getWebGLUniformMetadata, s as setWebGLUniformValue, e as setWebGLTextureParams, j as populateGLSLHooks, u as checkWebGLCapabilities } from '../rendering-C5lX6zKm.js';
 import { getStrokeDefs } from './enums.js';
 import { Shader } from './p5.Shader.js';
 import { R as RGB, h as RGBA } from '../creating_reading-DLkHH80h.js';
-import { I as Image } from '../p5.Renderer-BfhR0QHl.js';
+import { I as Image } from '../p5.Renderer-XOvhEbJn.js';
 import { g as glslBackend } from '../strands_glslBackend-D6G3UyCs.js';
 import '../strands/ir_types.js';
 import { getShaderHookTypes } from './shaderHookUtils.js';

package/dist/webgl/p5.Texture.js

@@ -1,8 +1,8 @@
-import '../constants-CdA3y5zC.js';
+import '../constants-Dv6ZqA6s.js';
 import '../dom/p5.Element.js';
-import '../p5.Renderer-BfhR0QHl.js';
+import '../p5.Renderer-XOvhEbJn.js';
 import '../dom/p5.MediaElement.js';
-export { M as MipmapTexture, T as Texture, t as default } from '../rendering-mbOOQwHM.js';
+export { M as MipmapTexture, T as Texture, t as default } from '../rendering-C5lX6zKm.js';
 import '../dom/p5.File.js';
 import '../io/p5.XML.js';
 import '../creating_reading-DLkHH80h.js';

package/dist/webgl/text.js

@@ -1,5 +1,5 @@
-import { a7 as TEXTURE, c as TRIANGLES } from '../constants-CdA3y5zC.js';
-import { R as Renderer3D } from '../rendering-mbOOQwHM.js';
+import { a7 as TEXTURE, c as TRIANGLES } from '../constants-Dv6ZqA6s.js';
+import { R as Renderer3D } from '../rendering-C5lX6zKm.js';
 import { Vector } from '../math/p5.Vector.js';
 import { Geometry } from './p5.Geometry.js';
 import { Font, arrayCommandsToObjects } from '../type/p5.Font.js';
@@ -10,7 +10,7 @@ import '../strands/ir_types.js';
 import '../dom/p5.Element.js';
 import '../dom/p5.File.js';
 import '../io/p5.XML.js';
-import '../p5.Renderer-BfhR0QHl.js';
+import '../p5.Renderer-XOvhEbJn.js';
 import '../image/filters.js';
 import '../shape/custom_shapes.js';
 import '../core/States.js';

package/dist/webgl/utils.js

@@ -1,13 +1,13 @@
-import '../constants-CdA3y5zC.js';
+import '../constants-Dv6ZqA6s.js';
 import '../strands/ir_types.js';
-export { u as checkWebGLCapabilities, h as getWebGLShaderAttributes, g as getWebGLUniformMetadata, j as populateGLSLHooks, o as readPixelWebGL, q as readPixelsWebGL, e as setWebGLTextureParams, s as setWebGLUniformValue } from '../rendering-mbOOQwHM.js';
+export { u as checkWebGLCapabilities, h as getWebGLShaderAttributes, g as getWebGLUniformMetadata, j as populateGLSLHooks, o as readPixelWebGL, q as readPixelsWebGL, e as setWebGLTextureParams, s as setWebGLUniformValue } from '../rendering-C5lX6zKm.js';
 import '../creating_reading-DLkHH80h.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
 import '../dom/p5.Element.js';
 import '../dom/p5.File.js';
 import '../io/p5.XML.js';
-import '../p5.Renderer-BfhR0QHl.js';
+import '../p5.Renderer-XOvhEbJn.js';
 import '../image/filters.js';
 import '../math/p5.Vector.js';
 import '../shape/custom_shapes.js';

package/dist/webgpu/index.js

@@ -1,5 +1,5 @@
 import rendererWebGPU from './p5.RendererWebGPU.js';
-import '../constants-CdA3y5zC.js';
+import '../constants-Dv6ZqA6s.js';
 import '../webgl/enums.js';
 import '../strands/ir_types.js';
 import './shaders/color.js';

package/dist/webgpu/p5.RendererWebGPU.js

@@ -1,4 +1,4 @@
-import { W as WEBGPU, T as TRIANGLE_STRIP, L as LIGHTEST, D as DARKEST, S as SUBTRACT, R as REPLACE, E as EXCLUSION, a as SCREEN, M as MULTIPLY, b as REMOVE, A as ADD, B as BLEND, c as TRIANGLES, U as UNSIGNED_BYTE, F as FLOAT, H as HALF_FLOAT, d as UNSIGNED_INT, e as MIRROR, f as REPEAT, C as CLAMP, g as LINEAR, N as NEAREST } from '../constants-CdA3y5zC.js';
+import { W as WEBGPU, T as TRIANGLE_STRIP, L as LIGHTEST, D as DARKEST, S as SUBTRACT, R as REPLACE, E as EXCLUSION, a as SCREEN, M as MULTIPLY, b as REMOVE, A as ADD, B as BLEND, c as TRIANGLES, U as UNSIGNED_BYTE, F as FLOAT, H as HALF_FLOAT, d as UNSIGNED_INT, e as MIRROR, f as REPEAT, C as CLAMP, g as LINEAR, N as NEAREST } from '../constants-Dv6ZqA6s.js';
 import { getStrokeDefs } from '../webgl/enums.js';
 import { DataType } from '../strands/ir_types.js';
 import { colorVertexShader, colorFragmentShader } from './shaders/color.js';

package/lib/p5.esm.js

@@ -1,4 +1,4 @@
-/*! p5.js v2.3.0-rc.5 May 21, 2026 */
+/*! p5.js v2.3.0 May 28, 2026 */
 /**
  * @module Constants
  * @submodule Constants
@@ -12,7 +12,7 @@ const _PI = Math.PI;
  * @property {String} VERSION
  * @final
  */
-const VERSION = '2.3.0-rc.5';
+const VERSION = '2.3.0';
 
 // GRAPHICS RENDERER
 /**
@@ -19791,8 +19791,14 @@ if(typeof p5 !== 'undefined'){
  * 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;
 };
 
 /**
@@ -20086,17 +20092,12 @@ class Vector {
   }
 
   /**
-   * 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.
@@ -20181,8 +20182,6 @@ class Vector {
     }
   }
 
-
-
   /**
    * Adds to a vector's components.
    *
@@ -20190,11 +20189,10 @@ class Vector {
    * 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.
    *
@@ -20311,7 +20309,7 @@ class Vector {
    * @param  {p5.Vector|Number[]} value The vector to add
    * @chainable
    */
-  add(...args) {
+  add(args) {
     const minDimension = prioritizeSmallerDimension(this.dimensions, args);
     shrinkToDimension(this.values, minDimension);
 
@@ -20322,11 +20320,8 @@ class Vector {
     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
@@ -20336,8 +20331,8 @@ class Vector {
    * 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]`.
    *
@@ -20435,13 +20430,20 @@ class Vector {
    * @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;
       }
     }
 
@@ -20449,7 +20451,7 @@ class Vector {
   }
 
   /**
-   * 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
@@ -20457,8 +20459,8 @@ class Vector {
    *
    * 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]`.
    *
@@ -20570,7 +20572,7 @@ class Vector {
    * @param  {p5.Vector|Number[]} value the vector to subtract
    * @chainable
    */
-  sub(...args) {
+  sub(args) {
     const minDimension = prioritizeSmallerDimension(this.dimensions, args);
     shrinkToDimension(this.values, minDimension);
 
@@ -20582,7 +20584,7 @@ class Vector {
   }
 
   /**
-   * 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
@@ -20592,8 +20594,8 @@ class Vector {
    * 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]`.
    *
@@ -20758,19 +20760,25 @@ class Vector {
    * @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
@@ -20780,8 +20788,8 @@ class Vector {
    * 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]`.
    *
@@ -20947,24 +20955,41 @@ class Vector {
    * @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;
@@ -108358,7 +108383,7 @@ if (typeof p5 !== 'undefined') {
 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'
       );
@@ -108379,7 +108404,7 @@ function _defaultEmptyVector(target){
  */
 function _validatedVectorOperation(expectsSoloNumberArgument){
   return function(target){
-    return function(...args){
+    return function (...args) {
       if (args.length === 0) {
         // No arguments? No action
         return this;
@@ -108389,16 +108414,18 @@ function _validatedVectorOperation(expectsSoloNumberArgument){
       } 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'
@@ -108407,9 +108434,19 @@ function _validatedVectorOperation(expectsSoloNumberArgument){
             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);
     };
   };
 }