p5 2.2.0-rc.3 → 2.2.0-rc.4

package/dist/math/Matrices/MatrixNumjs.js

@@ -1,7 +1,7 @@
 import nj from '@d4c/numjs/build/module/numjs.min.js';
 import { Vector } from '../p5.Vector.js';
 import { MatrixInterface } from './MatrixInterface.js';
-import '../../constants-J9QlHaWW.js';
+import '../../constants-DAarZ_Jd.js';
 
 let isMatrixArray = x => Array.isArray(x);
 if (typeof Float32Array !== 'undefined') {

package/dist/math/index.js

@@ -4,7 +4,7 @@ import random from './random.js';
 import trigonometry from './trigonometry.js';
 import math$1 from './math.js';
 import vector from './p5.Vector.js';
-import '../constants-J9QlHaWW.js';
+import '../constants-DAarZ_Jd.js';
 
 function math(p5){
   p5.registerAddon(calculation);

package/dist/math/p5.Matrix.js

@@ -1,6 +1,6 @@
 import { Matrix } from './Matrices/Matrix.js';
 import './p5.Vector.js';
-import '../constants-J9QlHaWW.js';
+import '../constants-DAarZ_Jd.js';
 import './Matrices/MatrixInterface.js';
 
 /**

package/dist/math/p5.Vector.js

@@ -1,4 +1,4 @@
-import { q as TWO_PI } from '../constants-J9QlHaWW.js';
+import { q as TWO_PI } from '../constants-DAarZ_Jd.js';
 
 /**
  * @module Math

package/dist/math/trigonometry.js

@@ -1,4 +1,4 @@
-import { a5 as RAD_TO_DEG, a6 as DEG_TO_RAD } from '../constants-J9QlHaWW.js';
+import { a5 as RAD_TO_DEG, a6 as DEG_TO_RAD } from '../constants-DAarZ_Jd.js';
 
 /**
  * @module Math

package/dist/{p5.Renderer-CQfJjPpD.js → p5.Renderer-Ds3PCIgb.js}

@@ -1,5 +1,5 @@
 import { C as Color } from './creating_reading-p2iQtNm5.js';
-import { a2 as NORMAL, aA as WORD, ax as BASELINE, av as LEFT, v as CENTER, p as CORNER, J as INCLUDE } from './constants-J9QlHaWW.js';
+import { a2 as NORMAL, aA as WORD, ax as BASELINE, av as LEFT, v as CENTER, p as CORNER, J as INCLUDE } from './constants-DAarZ_Jd.js';
 import Filters from './image/filters.js';
 import { Vector } from './math/p5.Vector.js';
 import { Shape } from './shape/custom_shapes.js';

package/dist/{rendering-IbeJmcSe.js → rendering-DPysJ2_4.js}

@@ -1,7 +1,7 @@
-import { p as CORNER, t as CORNERS, v as CENTER, aB as COVER, aC as CONTAIN, a9 as RIGHT, aw as BOTTOM, B as BLEND, aD as FILL, ad as IMAGE, C as CLAMP, w as ROUND, Y as LINES, X as POINTS, c as TRIANGLES, ab as BLUR, D as DARKEST, L as LIGHTEST, A as ADD, S as SUBTRACT, a as SCREEN, E as EXCLUSION, R as REPLACE, M as MULTIPLY, b as REMOVE, as as BURN, ao as OVERLAY, ap as HARD_LIGHT, aq as SOFT_LIGHT, ar as DODGE, d as UNSIGNED_INT, U as UNSIGNED_BYTE, av as LEFT, ax as BASELINE, ay as TOP, aE as SIMPLE, aF as FULL, q as TWO_PI, Q as OPEN, a2 as NORMAL, V as CLOSE, at as PIE, au as CHORD, h as TEXTURE, P as P2D, g as LINEAR, aa as WEBGL2, N as NEAREST, aG as LINEAR_MIPMAP, f as REPEAT, e as MIRROR, F as FLOAT, ac as WEBGL, H as HALF_FLOAT } from './constants-J9QlHaWW.js';
+import { p as CORNER, t as CORNERS, v as CENTER, aB as COVER, aC as CONTAIN, a9 as RIGHT, aw as BOTTOM, B as BLEND, aD as FILL, ad as IMAGE, C as CLAMP, w as ROUND, Y as LINES, X as POINTS, c as TRIANGLES, ab as BLUR, D as DARKEST, L as LIGHTEST, A as ADD, S as SUBTRACT, a as SCREEN, E as EXCLUSION, R as REPLACE, M as MULTIPLY, b as REMOVE, as as BURN, ao as OVERLAY, ap as HARD_LIGHT, aq as SOFT_LIGHT, ar as DODGE, d as UNSIGNED_INT, U as UNSIGNED_BYTE, av as LEFT, ax as BASELINE, ay as TOP, aE as SIMPLE, aF as FULL, q as TWO_PI, Q as OPEN, a2 as NORMAL, V as CLOSE, at as PIE, au as CHORD, h as TEXTURE, P as P2D, g as LINEAR, aa as WEBGL2, N as NEAREST, aG as LINEAR_MIPMAP, f as REPEAT, e as MIRROR, F as FLOAT, ac as WEBGL, H as HALF_FLOAT } from './constants-DAarZ_Jd.js';
 import { C as Color, c as creatingReading, h as RGBA, R as RGB } from './creating_reading-p2iQtNm5.js';
 import { Element } from './dom/p5.Element.js';
-import { R as Renderer, I as Image } from './p5.Renderer-CQfJjPpD.js';
+import { R as Renderer, I as Image } from './p5.Renderer-Ds3PCIgb.js';
 import { MediaElement } from './dom/p5.MediaElement.js';
 import primitives from './shape/2d_primitives.js';
 import attributes from './shape/attributes.js';
@@ -9153,6 +9153,27 @@ class Renderer3D extends Renderer {
   }
 
   background(...args) {
+    const a0 = args[0];
+
+    const isImageLike =
+      a0 != null &&
+      typeof a0 === 'object' &&
+      typeof a0.width === 'number' &&
+      typeof a0.height === 'number' &&
+      (a0.canvas != null || a0.elt != null);
+
+    // WEBGL / 3D: support background(image-like)
+    if (isImageLike) {
+      this._pInst.clear();
+      this._pInst.push();
+      this._pInst.resetMatrix();
+      this._pInst.imageMode(CENTER);
+      this._pInst.image(a0, 0, 0, this._pInst.width, this._pInst.height);
+      this._pInst.pop();
+      return;
+    }
+
+    // Default: background(color)
     const _col = this._pInst.color(...args);
     this.clear(..._col._getRGBA());
   }
@@ -10315,14 +10336,14 @@ class Renderer3D extends Renderer {
   _getSphereMapping(img) {
     if (!this.sphereMapping) {
       const p5 = this._pInst;
-      this.sphereMapping = this.baseFilterShader().modify(() => {
-        const uEnvMap = p5.uniformTexture();
-        const uFovY = p5.uniformFloat();
-        const uAspect = p5.uniformFloat();
+      this.sphereMapping = this.baseFilterShader().modify(({ p5 }) => {
+        const uEnvMap = p5.uniformTexture('uEnvMap');
+        const uFovY = p5.uniformFloat('uFovY');
+        const uAspect = p5.uniformFloat('uAspect');
         // Hack: we don't have matrix uniforms yet; use three vectors
-        const uN1 = p5.uniformVec3();
-        const uN2 = p5.uniformVec3();
-        const uN3 = p5.uniformVec3();
+        const uN1 = p5.uniformVec3('uN1');
+        const uN2 = p5.uniformVec3('uN2');
+        const uN3 = p5.uniformVec3('uN3');
         p5.getColor((inputs) => {
           const uFovX = uFovY * uAspect;
           const angleY = p5.mix(uFovY/2.0,  -uFovY/2.0, inputs.texCoord.y);

package/dist/shape/2d_primitives.js

@@ -1,4 +1,4 @@
-import { p as CORNER, q as TWO_PI, r as HALF_PI, s as PI } from '../constants-J9QlHaWW.js';
+import { p as CORNER, q as TWO_PI, r as HALF_PI, s as PI } from '../constants-DAarZ_Jd.js';
 import canvas from '../core/helpers.js';
 
 /**

package/dist/shape/attributes.js

@@ -1,4 +1,4 @@
-import { p as CORNER, t as CORNERS, u as RADIUS, v as CENTER, w as ROUND, x as SQUARE, y as PROJECT, z as BEVEL, I as MITER } from '../constants-J9QlHaWW.js';
+import { p as CORNER, t as CORNERS, u as RADIUS, v as CENTER, w as ROUND, x as SQUARE, y as PROJECT, z as BEVEL, I as MITER } from '../constants-DAarZ_Jd.js';
 
 /**
  * @module Shape

package/dist/shape/custom_shapes.js

@@ -1,6 +1,6 @@
 import { C as Color } from '../creating_reading-p2iQtNm5.js';
 import { Vector } from '../math/p5.Vector.js';
-import { J as INCLUDE, K as PATH, O as EMPTY_PATH, Q as OPEN, V as CLOSE, X as POINTS, Y as LINES, c as TRIANGLES, Z as QUADS, _ as TRIANGLE_FAN, T as TRIANGLE_STRIP, $ as QUAD_STRIP, a0 as EXCLUDE, a1 as JOIN } from '../constants-J9QlHaWW.js';
+import { J as INCLUDE, K as PATH, O as EMPTY_PATH, Q as OPEN, V as CLOSE, X as POINTS, Y as LINES, c as TRIANGLES, Z as QUADS, _ as TRIANGLE_FAN, T as TRIANGLE_STRIP, $ as QUAD_STRIP, a0 as EXCLUDE, a1 as JOIN } from '../constants-DAarZ_Jd.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
 

package/dist/shape/index.js

@@ -3,7 +3,7 @@ import attributes from './attributes.js';
 import curves from './curves.js';
 import vertex from './vertex.js';
 import customShapes from './custom_shapes.js';
-import '../constants-J9QlHaWW.js';
+import '../constants-DAarZ_Jd.js';
 import '../core/helpers.js';
 import '../creating_reading-p2iQtNm5.js';
 import 'colorjs.io/fn';

package/dist/strands/p5.strands.js

@@ -76,7 +76,7 @@ function strands(p5, fn) {
 
   p5.Shader.prototype.modify = function (shaderModifier, scope = {}) {
     try {
-      if (shaderModifier instanceof Function) {
+      if (shaderModifier instanceof Function || typeof shaderModifier === 'string') {
         // Reset the context object every time modify is called;
         // const backend = glslBackend;
         initStrandsContext(strandsContext, this._renderer.strandsBackend, {
@@ -93,7 +93,9 @@ function strands(p5, fn) {
         if (options.parser) {
           // #7955 Wrap function declaration code in brackets so anonymous functions are not top level statements, which causes an error in acorn when parsing
           // https://github.com/acornjs/acorn/issues/1385
-          const sourceString = `(${shaderModifier.toString()})`;
+          const sourceString = typeof shaderModifier === 'string'
+            ? `(${shaderModifier})`
+            : `(${shaderModifier.toString()})`;
           strandsCallback = transpileStrandsToJS(
             p5,
             sourceString,

package/dist/strands/strands_for.js

@@ -360,7 +360,7 @@ class StrandsFor {
     popBlock(cfg);
 
     const loopVarNode = createStrandsNode(phiNode.id, phiNode.dimension, this.strandsContext);
-    this.bodyResults = this.bodyCb(loopVarNode, phiVars);
+    this.bodyResults = this.bodyCb(loopVarNode, phiVars) || {};
     for (const key in this.bodyResults) {
       this.bodyResults[key] = this.strandsContext.p5.strandsNode(this.bodyResults[key]);
     }

package/dist/strands/strands_transpiler.js

@@ -112,41 +112,53 @@ const ASTCallbacks = {
   VariableDeclarator(node, _state, ancestors) {
     if (ancestors.some(nodeIsUniform)) { return; }
     if (nodeIsUniform(node.init)) {
-      const uniformNameLiteral = {
-        type: 'Literal',
-        value: node.id.name
-      };
-      node.init.arguments.unshift(uniformNameLiteral);
+      // Only inject the variable name if the first argument isn't already a string
+      if (node.init.arguments.length === 0 ||
+          node.init.arguments[0].type !== 'Literal' ||
+          typeof node.init.arguments[0].value !== 'string') {
+        const uniformNameLiteral = {
+          type: 'Literal',
+          value: node.id.name
+        };
+        node.init.arguments.unshift(uniformNameLiteral);
+      }
     }
     if (nodeIsVarying(node.init)) {
-      const varyingNameLiteral = {
-        type: 'Literal',
-        value: node.id.name
-      };
-      node.init.arguments.unshift(varyingNameLiteral);
-      _state.varyings[node.id.name] = varyingNameLiteral;
+      // Only inject the variable name if the first argument isn't already a string
+      if (
+        node.init.arguments.length === 0 ||
+        node.init.arguments[0].type !== 'Literal' ||
+        typeof node.init.arguments[0].value !== 'string'
+      ) {
+        const varyingNameLiteral = {
+          type: 'Literal',
+          value: node.id.name
+        };
+        node.init.arguments.unshift(varyingNameLiteral);
+        _state.varyings[node.id.name] = varyingNameLiteral;
+      } else {
+        // Still track it as a varying even if name wasn't injected
+        _state.varyings[node.id.name] = node.init.arguments[0];
+      }
     }
   },
   Identifier(node, _state, ancestors) {
     if (ancestors.some(nodeIsUniform)) { return; }
     if (_state.varyings[node.name]
       && !ancestors.some(a => a.type === 'AssignmentExpression' && a.left === node)) {
-        node.type = 'ExpressionStatement';
-        node.expression = {
-          type: 'CallExpression',
-          callee: {
-            type: 'MemberExpression',
-            object: {
-              type: 'Identifier',
-              name: node.name
-            },
-            property: {
-              type: 'Identifier',
-              name: 'getValue'
-            },
+        node.type = 'CallExpression';
+        node.callee = {
+          type: 'MemberExpression',
+          object: {
+            type: 'Identifier',
+            name: node.name
+          },
+          property: {
+            type: 'Identifier',
+            name: 'getValue'
           },
-          arguments: [],
         };
+        node.arguments = [];
       }
     },
     // The callbacks for AssignmentExpression and BinaryExpression handle
@@ -209,13 +221,12 @@ const ASTCallbacks = {
           varyingName = node.left.object.name;
         }
         // Check if it's a getValue() call: myVarying.getValue().xyz
-        else if (node.left.object.type === 'ExpressionStatement' &&
-                 node.left.object.expression?.type === 'CallExpression' &&
-                 node.left.object.expression.callee?.type === 'MemberExpression' &&
-                 node.left.object.expression.callee.property?.name === 'getValue' &&
-                 node.left.object.expression.callee.object?.type === 'Identifier' &&
-                 _state.varyings[node.left.object.expression.callee.object.name]) {
-          varyingName = node.left.object.expression.callee.object.name;
+        else if (node.left.object.type === 'CallExpression' &&
+                 node.left.object.callee?.type === 'MemberExpression' &&
+                 node.left.object.callee.property?.name === 'getValue' &&
+                 node.left.object.callee.object?.type === 'Identifier' &&
+                 _state.varyings[node.left.object.callee.object.name]) {
+          varyingName = node.left.object.callee.object.name;
         }
 
         if (varyingName) {
@@ -276,6 +287,37 @@ const ASTCallbacks = {
       };
       node.arguments = [node.right];
     },
+    LogicalExpression(node, _state, ancestors) {
+      // Don't convert uniform default values to node methods, as
+      // they should be evaluated at runtime, not compiled.
+      if (ancestors.some(nodeIsUniform)) { return; }
+      // If the left hand side of an expression is one of these types,
+      // we should construct a node from it.
+      const unsafeTypes = ['Literal', 'ArrayExpression', 'Identifier'];
+      if (unsafeTypes.includes(node.left.type)) {
+        const leftReplacementNode = {
+          type: 'CallExpression',
+          callee: {
+            type: 'Identifier',
+            name: '__p5.strandsNode',
+          },
+          arguments: [node.left]
+        };
+        node.left = leftReplacementNode;
+      }
+      // Replace the logical operator with a call expression
+      // in other words a call to BaseNode.or(), .and() etc.
+      node.type = 'CallExpression';
+      node.callee = {
+        type: 'MemberExpression',
+        object: node.left,
+        property: {
+          type: 'Identifier',
+          name: replaceBinaryOperator(node.operator),
+        },
+      };
+      node.arguments = [node.right];
+    },
     IfStatement(node, _state, ancestors) {
       if (ancestors.some(nodeIsUniform)) { return; }
       // Transform if statement into strandsIf() call
@@ -336,24 +378,56 @@ const ASTCallbacks = {
       };
       // Analyze which outer scope variables are assigned in any branch
       const assignedVars = new Set();
-      const analyzeBlock = (body) => {
-        if (body.type !== 'BlockStatement') return;
-        // First pass: collect variable declarations within this block
-        const localVars = new Set();
-        for (const stmt of body.body) {
+
+      // Helper function to check if a block contains strands control flow calls as immediate children
+      const blockContainsStrandsControlFlow = (node) => {
+        if (node.type !== 'BlockStatement') return false;
+        return node.body.some(stmt => {
+          // Check for variable declarations with strands control flow init
           if (stmt.type === 'VariableDeclaration') {
-            for (const decl of stmt.declarations) {
-              if (decl.id.type === 'Identifier') {
-                localVars.add(decl.id.name);
-              }
+            const match = stmt.declarations.some(decl =>
+              decl.init?.type === 'CallExpression' &&
+              (
+                (
+                  decl.init?.callee?.type === 'MemberExpression' &&
+                  decl.init?.callee?.object?.type === 'Identifier' &&
+                  decl.init?.callee?.object?.name === '__p5' &&
+                  (decl.init?.callee?.property?.name === 'strandsFor' ||
+                    decl.init?.callee?.property?.name === 'strandsIf')
+                ) ||
+                (
+                  decl.init?.callee?.type === 'Identifier' &&
+                  (decl.init?.callee?.name === '__p5.strandsFor' ||
+                    decl.init?.callee?.name === '__p5.strandsIf')
+                )
+              )
+            );
+            return match
+          }
+          return false;
+        });
+      };
+
+      const analyzeBranch = (functionBody) => {
+        // First pass: collect all variable declarations in the branch
+        const localVars = new Set();
+        ancestor(functionBody, {
+          VariableDeclarator(node, ancestors) {
+            // Skip if we're inside a block that contains strands control flow
+            if (ancestors.some(blockContainsStrandsControlFlow)) return;
+            if (node.id.type === 'Identifier') {
+              localVars.add(node.id.name);
             }
           }
-        }
-        // Second pass: find assignments to non-local variables
-        for (const stmt of body.body) {
-          if (stmt.type === 'ExpressionStatement' &&
-              stmt.expression.type === 'AssignmentExpression') {
-            const left = stmt.expression.left;
+        });
+
+        // Second pass: find assignments to non-local variables using acorn-walk
+        ancestor(functionBody, {
+          AssignmentExpression(node, ancestors) {
+            // Skip if we're inside a block that contains strands control flow
+            if (ancestors.some(blockContainsStrandsControlFlow)) return;
+
+            const left = node.left;
             if (left.type === 'Identifier') {
               // Direct variable assignment: x = value
               if (!localVars.has(left.name)) {
@@ -361,20 +435,18 @@ const ASTCallbacks = {
               }
             } else if (left.type === 'MemberExpression' &&
                        left.object.type === 'Identifier') {
-              // Property assignment: obj.prop = value
+              // Property assignment: obj.prop = value (includes swizzles)
               if (!localVars.has(left.object.name)) {
                 assignedVars.add(left.object.name);
               }
             }
-          } else if (stmt.type === 'BlockStatement') {
-            // Recursively analyze nested block statements
-            analyzeBlock(stmt);
           }
-        }
+        });
       };
+
       // Analyze all branches for assignments to outer scope variables
-      analyzeBlock(thenFunction.body);
-      analyzeBlock(elseFunction.body);
+      analyzeBranch(thenFunction.body);
+      analyzeBranch(elseFunction.body);
       if (assignedVars.size > 0) {
         // Add copying, reference replacement, and return statements to branch functions
         const addCopyingAndReturn = (functionBody, varsToReturn) => {
@@ -565,7 +637,7 @@ const ASTCallbacks = {
 
       // Transform for statement into strandsFor() call
       // for (init; test; update) body -> strandsFor(initCb, conditionCb, updateCb, bodyCb, initialVars)
-      
+
       // Generate unique loop variable name
       const uniqueLoopVar = `loopVar${loopVarCounter++}`;
 
@@ -684,46 +756,71 @@ const ASTCallbacks = {
 
       // Analyze which outer scope variables are assigned in the loop body
       const assignedVars = new Set();
-      const analyzeBlock = (body, parentLocalVars = new Set()) => {
-        if (body.type !== 'BlockStatement') return;
 
-        // First pass: collect variable declarations within this block
-        const localVars = new Set([...parentLocalVars]);
-        for (const stmt of body.body) {
+      // Helper function to check if a block contains strands control flow calls as immediate children
+      const blockContainsStrandsControlFlow = (node) => {
+        if (node.type !== 'BlockStatement') return false;
+        return node.body.some(stmt => {
+          // Check for variable declarations with strands control flow init
           if (stmt.type === 'VariableDeclaration') {
-            for (const decl of stmt.declarations) {
-              if (decl.id.type === 'Identifier') {
-                localVars.add(decl.id.name);
-              }
-            }
+            const match = stmt.declarations.some(decl =>
+              decl.init?.type === 'CallExpression' &&
+              (
+                (
+                  decl.init?.callee?.type === 'MemberExpression' &&
+                  decl.init?.callee?.object?.type === 'Identifier' &&
+                  decl.init?.callee?.object?.name === '__p5' &&
+                  (decl.init?.callee?.property?.name === 'strandsFor' ||
+                    decl.init?.callee?.property?.name === 'strandsIf')
+                ) ||
+                (
+                  decl.init?.callee?.type === 'Identifier' &&
+                  (decl.init?.callee?.name === '__p5.strandsFor' ||
+                    decl.init?.callee?.name === '__p5.strandsIf')
+                )
+              )
+            );
+            return match
+          }
+          return false;
+        });
+      };
+
+      // First pass: collect all variable declarations in the body
+      const localVars = new Set();
+      ancestor(bodyFunction.body, {
+        VariableDeclarator(node, ancestors) {
+          // Skip if we're inside a block that contains strands control flow
+          if (ancestors.some(blockContainsStrandsControlFlow)) return;
+          if (node.id.type === 'Identifier') {
+            localVars.add(node.id.name);
           }
         }
+      });
 
-        // Second pass: find assignments to non-local variables
-        for (const stmt of body.body) {
-          if (stmt.type === 'ExpressionStatement' &&
-              stmt.expression.type === 'AssignmentExpression') {
-            const left = stmt.expression.left;
-            if (left.type === 'Identifier') {
-              // Direct variable assignment: x = value
-              if (!localVars.has(left.name)) {
-                assignedVars.add(left.name);
-              }
-            } else if (left.type === 'MemberExpression' &&
-                       left.object.type === 'Identifier') {
-              // Property assignment: obj.prop = value (includes swizzles)
-              if (!localVars.has(left.object.name)) {
-                assignedVars.add(left.object.name);
-              }
+      // Second pass: find assignments to non-local variables using acorn-walk
+      ancestor(bodyFunction.body, {
+        AssignmentExpression(node, ancestors) {
+          // Skip if we're inside a block that contains strands control flow
+          if (ancestors.some(blockContainsStrandsControlFlow)) {
+            return
+          }
+
+          const left = node.left;
+          if (left.type === 'Identifier') {
+            // Direct variable assignment: x = value
+            if (!localVars.has(left.name)) {
+              assignedVars.add(left.name);
+            }
+          } else if (left.type === 'MemberExpression' &&
+                     left.object.type === 'Identifier') {
+            // Property assignment: obj.prop = value (includes swizzles)
+            if (!localVars.has(left.object.name)) {
+              assignedVars.add(left.object.name);
             }
-          } else if (stmt.type === 'BlockStatement') {
-            // Recursively analyze nested block statements, passing down local vars
-            analyzeBlock(stmt, localVars);
           }
         }
-      };
-
-      analyzeBlock(bodyFunction.body);
+      });
 
       if (assignedVars.size > 0) {
         // Add copying, reference replacement, and return statements similar to if statements
@@ -929,7 +1026,7 @@ const ASTCallbacks = {
     // Reset counters at the start of each transpilation
     blockVarCounter = 0;
     loopVarCounter = 0;
-    
+
     const ast = parse(sourceString, {
       ecmaVersion: 2021,
       locations: srcLocations
@@ -962,20 +1059,39 @@ const ASTCallbacks = {
     recursive(ast, { varyings: {} }, postOrderControlFlowTransform);
     const transpiledSource = escodegen.generate(ast);
     const scopeKeys = Object.keys(scope);
-    const internalStrandsCallback = new Function(
-        // Create a parameter called __p5, not just p5, because users of instance mode
-        // may pass in a variable called p5 as a scope variable. If we rely on a variable called
-        // p5, then the scope variable called p5 might accidentally override internal function
-        // calls to p5 static methods.
-      '__p5',
-      ...scopeKeys,
-      transpiledSource
-      .slice(
-        transpiledSource.indexOf('{') + 1,
-        transpiledSource.lastIndexOf('}')
-      ).replaceAll(';', '')
-    );
-    return () => internalStrandsCallback(p5, ...scopeKeys.map(key => scope[key]));
+    const match = /\(?\s*(?:function)?\s*\(([^)]*)\)\s*(?:=>)?\s*{((?:.|\n)*)}\s*;?\s*\)?/
+      .exec(transpiledSource);
+    if (!match) {
+      console.log(transpiledSource);
+      throw new Error('Could not parse p5.strands function!');
+    }
+    const params = match[1].split(/,\s*/).filter(param => !!param.trim());
+    let paramVals, paramNames;
+    if (params.length > 0) {
+      paramNames = params;
+      paramVals = [scope];
+    } else {
+      paramNames = scopeKeys;
+      paramVals = scopeKeys.map(key => scope[key]);
+    }
+    const body = match[2];
+    try {
+      const internalStrandsCallback = new Function(
+          // Create a parameter called __p5, not just p5, because users of instance mode
+          // may pass in a variable called p5 as a scope variable. If we rely on a variable called
+          // p5, then the scope variable called p5 might accidentally override internal function
+          // calls to p5 static methods.
+        '__p5',
+        ...paramNames,
+        body,
+      );
+      return () => internalStrandsCallback(p5, ...paramVals);
+    } catch (e) {
+      console.error(e);
+      console.log(paramNames);
+      console.log(body);
+      throw new Error('Error transpiling p5.strands callback!');
+    }
   }
 
 export { transpileStrandsToJS };

package/dist/type/index.js

@@ -1,10 +1,10 @@
 import textCore from './textCore.js';
 import font from './p5.Font.js';
-import '../p5.Renderer-CQfJjPpD.js';
+import '../p5.Renderer-Ds3PCIgb.js';
 import '../creating_reading-p2iQtNm5.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
-import '../constants-J9QlHaWW.js';
+import '../constants-DAarZ_Jd.js';
 import '../image/filters.js';
 import '../math/p5.Vector.js';
 import '../shape/custom_shapes.js';

package/dist/type/p5.Font.js

@@ -1,11 +1,11 @@
 import { textCoreConstants } from './textCore.js';
-import { v as CENTER, a9 as RIGHT, u as RADIUS } from '../constants-J9QlHaWW.js';
+import { v as CENTER, a9 as RIGHT, u as RADIUS } from '../constants-DAarZ_Jd.js';
 import { UnicodeRange } from '@japont/unicode-range';
 import { unicodeRanges } from './unicodeRanges.js';
 import { Vector } from '../math/p5.Vector.js';
 import Typr from './lib/Typr.js';
 import { createFromCommands } from '@davepagurek/bezier-path';
-import '../p5.Renderer-CQfJjPpD.js';
+import '../p5.Renderer-Ds3PCIgb.js';
 import '../creating_reading-p2iQtNm5.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';

package/dist/type/textCore.js

@@ -1,8 +1,8 @@
-import { R as Renderer } from '../p5.Renderer-CQfJjPpD.js';
+import { R as Renderer } from '../p5.Renderer-Ds3PCIgb.js';
 import '../creating_reading-p2iQtNm5.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
-import '../constants-J9QlHaWW.js';
+import '../constants-DAarZ_Jd.js';
 import '../image/filters.js';
 import '../math/p5.Vector.js';
 import '../shape/custom_shapes.js';

package/dist/webgl/3d_primitives.js

@@ -1,5 +1,5 @@
-import '../constants-J9QlHaWW.js';
-export { p as default } from '../rendering-IbeJmcSe.js';
+import '../constants-DAarZ_Jd.js';
+export { p as default } from '../rendering-DPysJ2_4.js';
 import '../math/p5.Vector.js';
 import './p5.Geometry.js';
 import '../math/p5.Matrix.js';
@@ -10,7 +10,7 @@ import '../color/color_spaces/hsb.js';
 import '../dom/p5.Element.js';
 import '../dom/p5.File.js';
 import '../io/p5.XML.js';
-import '../p5.Renderer-CQfJjPpD.js';
+import '../p5.Renderer-Ds3PCIgb.js';
 import '../image/filters.js';
 import '../shape/custom_shapes.js';
 import '../core/States.js';