p5 2.0.0 → 2.0.1

package/{src → dist}/webgl/ShaderGenerator.js

@@ -1,24 +1,25 @@
+import { parse } from 'acorn';
+import { ancestor } from 'acorn-walk';
+import escodegen from 'escodegen';
+
 /**
 * @module 3D
 * @submodule ShaderGenerator
 * @for p5
 * @requires core
 */
-import { parse } from 'acorn';
-import { ancestor } from 'acorn-walk';
-import escodegen from 'escodegen';
 
 function shadergenerator(p5, fn) {
   let GLOBAL_SHADER;
   let BRANCH;
 
-  const oldModify = p5.Shader.prototype.modify
+  const oldModify = p5.Shader.prototype.modify;
 
   p5.Shader.prototype.modify = function(shaderModifier, options = { parser: true, srcLocations: false }) {
     if (shaderModifier instanceof Function) {
       let generatorFunction;
       if (options.parser) {
-        const sourceString = shaderModifier.toString()
+        const sourceString = shaderModifier.toString();
         const ast = parse(sourceString, {
           ecmaVersion: 2021,
           locations: options.srcLocations
@@ -42,7 +43,7 @@ function shadergenerator(p5, fn) {
     else {
       return oldModify.call(this, shaderModifier)
     }
-  }
+  };
 
   // AST Transpiler Callbacks and helper functions
   function replaceBinaryOperator(codeSource) {
@@ -75,16 +76,16 @@ function shadergenerator(p5, fn) {
       const signNode = {
         type: 'Literal',
         value: node.operator,
-      }
+      };
 
       const standardReplacement = (node) => {
-          node.type = 'CallExpression'
+          node.type = 'CallExpression';
           node.callee = {
             type: 'Identifier',
             name: 'unaryNode',
-          }
-          node.arguments = [node.argument, signNode]
-      }
+          };
+          node.arguments = [node.argument, signNode];
+      };
 
       if (node.type === 'MemberExpression') {
         const property = node.argument.property.name;
@@ -126,14 +127,14 @@ function shadergenerator(p5, fn) {
         const uniformNameLiteral = {
           type: 'Literal',
           value: node.id.name
-        }
+        };
         node.init.arguments.unshift(uniformNameLiteral);
       }
       if (node.init.callee && node.init.callee.name?.startsWith('varying')) {
         const varyingNameLiteral = {
           type: 'Literal',
           value: node.id.name
-        }
+        };
         node.init.arguments.unshift(varyingNameLiteral);
         _state.varyings[node.id.name] = varyingNameLiteral;
       }
@@ -156,7 +157,7 @@ function shadergenerator(p5, fn) {
             },
           },
           arguments: [],
-        }
+        };
       }
     },
     // The callbacks for AssignmentExpression and BinaryExpression handle
@@ -184,7 +185,7 @@ function shadergenerator(p5, fn) {
             },
           },
           arguments: [node.right]
-        }
+        };
           node.operator = '=';
           node.right = rightReplacementNode;
         }
@@ -204,7 +205,7 @@ function shadergenerator(p5, fn) {
               }
             },
             arguments: [node.right],
-          }
+          };
         }
       },
     BinaryExpression(node, _state, _ancestors) {
@@ -222,7 +223,7 @@ function shadergenerator(p5, fn) {
             name: 'dynamicNode',
           },
           arguments: [node.left]
-        }
+        };
         node.left = leftReplacementNode;
       }
       // Replace the binary operator with a call expression
@@ -238,7 +239,7 @@ function shadergenerator(p5, fn) {
       };
       node.arguments = [node.right];
     },
-  }
+  };
 
   // Javascript Node API.
   class BaseNode {
@@ -262,8 +263,7 @@ function shadergenerator(p5, fn) {
         } catch (e) {
           const lines = e.stack.split('\n');
           let userSketchLineIndex = 5;
-          if (isBinaryExpressionNode(this)) { userSketchLineIndex--; };
-          this.srcLine = lines[userSketchLineIndex].trim();
+          if (isBinaryExpressionNode(this)) { userSketchLineIndex--; }          this.srcLine = lines[userSketchLineIndex].trim();
         }
       }
     }
@@ -287,7 +287,7 @@ function shadergenerator(p5, fn) {
                 value = newValue;
               }
             }
-          })
+          });
         }
       }
     }
@@ -345,7 +345,7 @@ function shadergenerator(p5, fn) {
       } else {
         result = this.toGLSL(context);
       }
-      this.checkConditionalDependencies(context)
+      this.checkConditionalDependencies(context);
       return result;
     }
 
@@ -453,7 +453,7 @@ function shadergenerator(p5, fn) {
         x = x[0];
       }
       if (_parent) {
-        const { parent, name } = _parent
+        const { parent, name } = _parent;
         this.name = name;
         this.parent = parent;
       }
@@ -500,7 +500,7 @@ function shadergenerator(p5, fn) {
               value = isFloatNode(newValue) ? newValue : new FloatNode(newValue, true, info);
             }
           }
-        })
+        });
       });
       this.originalValues = this.componentNames.map(name => this[name]);
     }
@@ -531,16 +531,15 @@ function shadergenerator(p5, fn) {
           if (expectedArgType === 'genType') {
             // We allow conversions from float -> vec if one argument is a vector.
             if (genType === undefined || (genType === 'float' && userType.startsWith('vec'))) {
-              genType = userType
-            };
-            expectedArgType = genType;
+              genType = userType;
+            }            expectedArgType = genType;
           }
           similarity += (userType === expectedArgType);
           return userType === expectedArgType || (userType === 'float' && expectedArgType.startsWith('vec'));
-        })
+        });
 
         return { ...props, valid, similarity, genType }
-      }
+      };
 
       if (Array.isArray(properties)) {
         // Check if the right number of parameters were provided
@@ -560,7 +559,7 @@ function shadergenerator(p5, fn) {
             best = current;
           }
           return best;
-        }
+        };
         functionSignature = possibleOverloads.reduce(findBestOverload, null);
       } else {
         functionSignature = determineFunctionSignature(properties);
@@ -588,7 +587,7 @@ function shadergenerator(p5, fn) {
           arg = nodeConstructors[functionSignature.genType](arg);
         }
         return arg;
-      })
+      });
 
       if (functionSignature.returnType === 'genType') {
         functionSignature.returnType = functionSignature.genType;
@@ -665,7 +664,7 @@ function shadergenerator(p5, fn) {
         let { value } = val;
         context.declarations.push(`  ${this.name} = ${value.toGLSLBase(context)};`);
         if (i === values.length - 1) {
-          const tempName = `${this.name}_${this.tempVars++}`
+          const tempName = `${this.name}_${this.tempVars++}`;
           snapshot = dynamicAddSwizzleTrap(new VariableNode(tempName, this.type, true));
           context.declarations.push(`  ${this.type} ${tempName} = ${this.name};`);
         }
@@ -677,10 +676,10 @@ function shadergenerator(p5, fn) {
 
     bridge(value) {
       if (!isShaderNode(value) || this.type.startsWith('vec') && getType(value) === 'float') {
-        value = nodeConstructors[this.type](value)
+        value = nodeConstructors[this.type](value);
       }
       GLOBAL_SHADER.registerVarying(this, value);
-      this.timesChanged += 1
+      this.timesChanged += 1;
     }
   }
 
@@ -755,7 +754,7 @@ function shadergenerator(p5, fn) {
 
   class UnaryExpressionNode extends BaseNode {
     constructor(node, operator, isInternal = false) {
-      super(isInternal, node.type)
+      super(isInternal, node.type);
       this.node = node;
       this.operator = operator;
     }
@@ -763,7 +762,7 @@ function shadergenerator(p5, fn) {
     toGLSL(context) {
       let mainStr = this.node.toGLSLBase(context);
       if (!isVariableNode(this.node) && !hasTemporaryVariable(this.node) && !isPrimitiveNode(this.node)) {
-        mainStr = `(${mainStr})`
+        mainStr = `(${mainStr})`;
       }
       return `${this.operator}${mainStr}`
     }
@@ -772,34 +771,34 @@ function shadergenerator(p5, fn) {
   // Conditions and logical modifiers
   BaseNode.prototype.equalTo = function(other) {
     return binaryExpressionNodeConstructor(this, this.enforceType(other), '==');
-  }
+  };
 
   BaseNode.prototype.greaterThan = function(other) {
     return binaryExpressionNodeConstructor(this, this.enforceType(other), '>');
-  }
+  };
 
   BaseNode.prototype.greaterThanEqualTo = function(other) {
     return binaryExpressionNodeConstructor(this, this.enforceType(other), '>=');
-  }
+  };
 
   BaseNode.prototype.lessThan = function(other) {
     return binaryExpressionNodeConstructor(this, this.enforceType(other), '<');
-  }
+  };
 
   BaseNode.prototype.lessThanEqualTo = function(other) {
-    return binaryExpressionNodeConstructor(this, this.enforceType(other), '<='); }
+    return binaryExpressionNodeConstructor(this, this.enforceType(other), '<='); };
 
   BaseNode.prototype.not = function() {
      return new UnaryExpressionNode(this.condition, '!', true);
-  }
+  };
 
   BaseNode.prototype.or = function(other) {
     return new binaryExpressionNodeConstructor(this, this.enforceType(other), '||', true);
-  }
+  };
 
   BaseNode.prototype.and = function(other) {
     return new binaryExpressionNodeConstructor(this, this.enforceType(other), '&&', true);
-  }
+  };
 
   function branch(callback) {
     const branch = new BranchNode();
@@ -838,7 +837,7 @@ function shadergenerator(p5, fn) {
 
     else(branchCallback) {
       this.elseBranch = branch(branchCallback);
-      this.elseBranch.parent = this
+      this.elseBranch.parent = this;
       return this;
     }
 
@@ -874,7 +873,7 @@ function shadergenerator(p5, fn) {
           codelines.push(` else if (${condition.toGLSL(context)}) {`);
           codelines.push(`\n    ${elseBranch.toGLSL(context)}`);
           codelines.push(`\n  }`);
-        })
+        });
       }
 
       if (this.elseBranch) {
@@ -885,14 +884,13 @@ function shadergenerator(p5, fn) {
       codelines.push('\n');
       return codelines.flat().join('');
     }
-  };
-
+  }
   fn.assign = function(node, value) {
     if (!BRANCH) {
        throw new error('assign() is supposed to be used inside of conditional branchs. Use the "=" operator as normal otherwise.');
     }
     BRANCH.assign(node, value);
-  }
+  };
 
   class BranchNode {
     constructor() {
@@ -907,10 +905,10 @@ function shadergenerator(p5, fn) {
           return parent;
         },
         set(newParent) {
-          newParent.dependsOn.push(...this.dependsOn)
+          newParent.dependsOn.push(...this.dependsOn);
           parent = newParent;
         }
-      })
+      });
     }
 
     assign(node, value) {
@@ -927,7 +925,7 @@ function shadergenerator(p5, fn) {
         return;
       }
       node.assertUsedInConditional(this);
-      this.dependsOn.push(makeDependencyObject(node))
+      this.dependsOn.push(makeDependencyObject(node));
       if (value.shouldUseTemporaryVariable()) {
         value.assertUsedInConditional(this);
         this.dependsOn.push(makeDependencyObject(value));
@@ -960,11 +958,11 @@ function shadergenerator(p5, fn) {
         }
         else {
           node.temporaryVariable = `temp_${context.getNextID()}`;
-          statement = `${node.type} ${node.toGLSLBase(context)} = ${result};`
+          statement = `${node.type} ${node.toGLSLBase(context)} = ${result};`;
         }
 
         this.statements.push(statement);
-      })
+      });
 
       return this.statements.join(`\n    `);
     }
@@ -1018,13 +1016,13 @@ function shadergenerator(p5, fn) {
     else if (Array.isArray(input)) {
       return nodeConstructors.dynamicVector(input);
     }
-  }
+  };
 
   // For replacing unary expressions
   fn.unaryNode = function(input, sign) {
     input = dynamicNode(input);
     return dynamicAddSwizzleTrap(new UnaryExpressionNode(input, sign));
-  }
+  };
 
   function isShaderNode(node) {
     return (node instanceof BaseNode);
@@ -1099,7 +1097,7 @@ function shadergenerator(p5, fn) {
         vertexDeclarations: new Set(),
         fragmentDeclarations: new Set(),
         uniforms: {},
-      }
+      };
       this.uniformNodes = [];
       this.resetGLSLContext();
       this.isGenerating = false;
@@ -1126,7 +1124,7 @@ function shadergenerator(p5, fn) {
       const availableHooks = {
         ...originalShader.hooks.vertex,
         ...originalShader.hooks.fragment,
-      }
+      };
 
       const windowOverrides = {};
 
@@ -1137,7 +1135,7 @@ function shadergenerator(p5, fn) {
         this[hookTypes.name] = function(userCallback) {
           // Create the initial nodes which are passed to the user callback
           // Also generate a string of the arguments for the code generation
-          const argNodes = []
+          const argNodes = [];
           const argsArray = [];
 
           hookTypes.parameters.forEach((parameter) => {
@@ -1154,8 +1152,8 @@ function shadergenerator(p5, fn) {
               );
             }
             const qualifiers = parameter.type.qualifiers.length > 0 ? parameter.type.qualifiers.join(' ') : '';
-            argsArray.push(`${qualifiers} ${parameter.type.typeName} ${parameter.name}`.trim())
-          })
+            argsArray.push(`${qualifiers} ${parameter.type.typeName} ${parameter.name}`.trim());
+          });
 
           let returnedValue = userCallback(...argNodes);
           const expectedReturnType = hookTypes.returnType;
@@ -1170,7 +1168,7 @@ function shadergenerator(p5, fn) {
             });
           } else {
             if (!isShaderNode(returnedValue)) {
-              returnedValue = nodeConstructors[expectedReturnType.typeName](returnedValue)
+              returnedValue = nodeConstructors[expectedReturnType.typeName](returnedValue);
             } else if (isFloatType(returnedValue) && expectedReturnType.typeName.startsWith('vec')) {
               returnedValue = nodeConstructors[expectedReturnType.typeName](returnedValue);
             }
@@ -1182,7 +1180,7 @@ function shadergenerator(p5, fn) {
             if (statement.usedIn.length === 0) { return; }
             const lines = statement.toGLSL(this.context);
             this.context.declarations.splice(statement.insertionPoint, 0, lines);
-          })
+          });
           // Build the final GLSL string.
           // The order of this code is a bit confusing, we need to call toGLSLBase
           let codeLines = [
@@ -1193,7 +1191,7 @@ function shadergenerator(p5, fn) {
 
           Object.entries(toGLSLResults).forEach(([propertyName, result]) => {
             const propString = expectedReturnType.properties ? `.${propertyName}` : '';
-            codeLines.push(`  finalReturnValue${propString} = ${result};`)
+            codeLines.push(`  finalReturnValue${propString} = ${result};`);
           });
 
           this.context.declarations = [];
@@ -1202,7 +1200,7 @@ function shadergenerator(p5, fn) {
             const finalVaryingAssignments = [];
             declArray.forEach(obj => {
               const { node, value } = obj;
-              finalVaryingAssignments.push(`  ${node.name} = ${value.toGLSLBase(this.context)};`)
+              finalVaryingAssignments.push(`  ${node.name} = ${value.toGLSLBase(this.context)};`);
               finalVaryingAssignments.unshift(...this.context.declarations);
               node.timesChanged = 0;
             });
@@ -1212,7 +1210,7 @@ function shadergenerator(p5, fn) {
           codeLines.push('  return finalReturnValue;', '}');
           this.output[hookName] = codeLines.join('\n');
           this.resetGLSLContext();
-        }
+        };
         windowOverrides[hookTypes.name] = window[hookTypes.name];
 
         // Expose the Functions to global scope for users to use
@@ -1269,18 +1267,18 @@ function shadergenerator(p5, fn) {
                 return node[name]
               });
               const replacement = nodeConstructors[node.type](components);
-              const line = `  ${node.temporaryVariable} = ${replacement.toGLSLBase(this)};`
+              const line = `  ${node.temporaryVariable} = ${replacement.toGLSLBase(this)};`;
               lines.push(line);
             }
             if (_emplaceAt) {
-              this.declarations.splice(_emplaceAt, 0, ...lines)
+              this.declarations.splice(_emplaceAt, 0, ...lines);
             } else {
               this.declarations.push(...lines);
             }
             node.componentsChanged = false;
           }
         }
-      }
+      };
       this.uniformNodes = [];
     }
   }
@@ -1366,7 +1364,6 @@ function shadergenerator(p5, fn) {
             propertyCharArray.forEach((char, i) => {
               const index = set.indexOf(char);
               const realProperty = swizzleSets[0][index];
-              const descriptor = Object.getOwnPropertyDescriptor(target, realProperty);
               Reflect.set(target, realProperty, newValues[i], receiver);
             });
             return true;
@@ -1380,16 +1377,16 @@ function shadergenerator(p5, fn) {
   // User functions
   fn.If = function (condition, branch) {
     return new ConditionalNode(condition, branch);
-  }
+  };
 
   fn.instanceID = function() {
     return variableConstructor('gl_InstanceID', 'int');
-  }
+  };
 
   fn.getTexture = function(...userArgs) {
     const props = { args: ['sampler2D', 'vec2'], returnType: 'vec4', isp5Function: true };
     return fnNodeConstructor('getTexture', userArgs,  props);
-  }
+  };
 
   // Generating uniformFloat, uniformVec, createFloat, etc functions
   // Maps a GLSL type to the name suffix for method names
@@ -1404,7 +1401,7 @@ function shadergenerator(p5, fn) {
 
   function dynamicAddSwizzleTrap(node, _size) {
     if (node.type.startsWith('vec') || _size) {
-      const size = _size ? _size : parseInt(node.type.slice(3));
+      const size = parseInt(node.type.slice(3));
       node =  new Proxy(node, swizzleTrap(size));
       node.addVectorComponents();
     }
@@ -1487,7 +1484,7 @@ function shadergenerator(p5, fn) {
     const varyingMethodName = `varying${typeIdentifier}`;
     ShaderGenerator.prototype[varyingMethodName] = function(name) {
       return dynamicAddSwizzleTrap(new VaryingNode(name, glslType, false));
-    }
+    };
 
     fn[varyingMethodName] = function (name) {
       return GLOBAL_SHADER[varyingMethodName](name);
@@ -1593,7 +1590,7 @@ function shadergenerator(p5, fn) {
 
     ////////// Texture sampling //////////
     'texture': {args: ['sampler2D', 'vec2'], returnType: 'vec4', isp5Function: true},
-  }
+  };
 
   Object.entries(builtInGLSLFunctions).forEach(([functionName, properties]) => {
     const isp5Function = Array.isArray(properties) ? properties[0].isp5Function : properties.isp5Function;
@@ -1605,7 +1602,7 @@ function shadergenerator(p5, fn) {
         } else {
           return originalFn.apply(this, args);
         }
-      }
+      };
     } else {
       fn[functionName] = function (...args) {
         if (GLOBAL_SHADER?.isGenerating) {
@@ -1615,13 +1612,13 @@ function shadergenerator(p5, fn) {
             `It looks like you've called ${functionName} outside of a shader's modify() function.`
           );
         }
-      }
+      };
     }
-  })
+  });
 }
 
-export default shadergenerator;
-
 if (typeof p5 !== 'undefined') {
-  p5.registerAddon(shadergenerator)
+  p5.registerAddon(shadergenerator);
 }
+
+export { shadergenerator as default };

package/{src → dist}/webgl/ShapeBuilder.js

@@ -1,8 +1,9 @@
-import * as constants from '../core/constants';
-import { Geometry } from './p5.Geometry';
-import libtess from 'libtess'; // Fixed with exporting module from libtess
-import { Vector } from '../math/p5.Vector';
-import { RenderBuffer } from './p5.RenderBuffer';
+import { m as PATH, Q as QUADS, s as QUAD_STRIP, r as TRIANGLE_STRIP, p as TRIANGLES, a1 as IMAGE, L as LINES, q as TRIANGLE_FAN } from '../constants-C-g_eAdC.js';
+import { Geometry } from './p5.Geometry.js';
+import libtess from 'libtess';
+import { Vector } from '../math/p5.Vector.js';
+import { RenderBuffer } from './p5.RenderBuffer.js';
+import './p5.DataArray.js';
 
 const INITIAL_BUFFER_STRIDES = {
   vertices: 1,
@@ -17,10 +18,10 @@ const INITIAL_BUFFER_STRIDES = {
 const INITIAL_VERTEX_SIZE =
   Object.values(INITIAL_BUFFER_STRIDES).reduce((acc, next) => acc + next);
 
-export class ShapeBuilder {
+class ShapeBuilder {
   constructor(renderer) {
     this.renderer = renderer;
-    this.shapeMode = constants.PATH;
+    this.shapeMode = PATH;
     this.geometry = new Geometry(undefined, undefined, undefined, this.renderer);
     this.geometry.gid = '__IMMEDIATE_MODE_GEOMETRY__';
 
@@ -74,7 +75,7 @@ export class ShapeBuilder {
         // QUADS into TRIANGLES and QUAD_STRIP into TRIANGLE_STRIP. (There is no extra
         // work to convert QUAD_STRIP here, since the only difference is in how edges
         // are rendered.)
-        if (this.shapeMode === constants.QUADS) {
+        if (this.shapeMode === QUADS) {
           // A finished quad turned into triangles should leave 6 vertices in the
           // buffer:
           // 0--3     0   3--5
@@ -126,25 +127,25 @@ export class ShapeBuilder {
       this.geometry._edgesToVertices();
     }
 
-    if (this.shapeMode === constants.PATH) {
+    if (this.shapeMode === PATH) {
       this.isProcessingVertices = true;
       this._tesselateShape();
       this.isProcessingVertices = false;
-    } else if (this.shapeMode === constants.QUAD_STRIP) {
+    } else if (this.shapeMode === QUAD_STRIP) {
       // The only difference between these two modes is which edges are
       // displayed, so after we've updated the edges, we switch the mode
       // to one that native WebGL knows how to render.
-      this.shapeMode = constants.TRIANGLE_STRIP;
-    } else if (this.shapeMode === constants.QUADS) {
+      this.shapeMode = TRIANGLE_STRIP;
+    } else if (this.shapeMode === QUADS) {
       // We translate QUADS to TRIANGLES when vertices are being added,
       // since QUADS is just a p5 mode, whereas TRIANGLES is also a mode
       // that native WebGL knows how to render. Once we've processed edges,
       // everything should be set up for TRIANGLES mode.
-      this.shapeMode = constants.TRIANGLES;
+      this.shapeMode = TRIANGLES;
     }
 
     if (
-      this.renderer.states.textureMode === constants.IMAGE &&
+      this.renderer.states.textureMode === IMAGE &&
       this.renderer.states._tex !== null &&
       this.renderer.states._tex.width > 0 &&
       this.renderer.states._tex.height > 0
@@ -155,7 +156,7 @@ export class ShapeBuilder {
         } else {
           return val / this.renderer.states._tex.height;
         }
-      })
+      });
     }
   }
 
@@ -186,33 +187,33 @@ export class ShapeBuilder {
     const contourIndices = this.contourIndices.slice();
     let contourStart = -1;
     switch (shapeMode) {
-      case constants.TRIANGLE_STRIP:
+      case TRIANGLE_STRIP:
         for (i = 0; i < verts.length - 2; i++) {
           res.push([i, i + 1]);
           res.push([i, i + 2]);
         }
         res.push([i, i + 1]);
         break;
-      case constants.TRIANGLE_FAN:
+      case TRIANGLE_FAN:
         for (i = 1; i < verts.length - 1; i++) {
           res.push([0, i]);
           res.push([i, i + 1]);
         }
         res.push([0, verts.length - 1]);
         break;
-      case constants.TRIANGLES:
+      case TRIANGLES:
         for (i = 0; i < verts.length - 2; i = i + 3) {
           res.push([i, i + 1]);
           res.push([i + 1, i + 2]);
           res.push([i + 2, i]);
         }
         break;
-      case constants.LINES:
+      case LINES:
         for (i = 0; i < verts.length - 1; i = i + 2) {
           res.push([i, i + 1]);
         }
         break;
-      case constants.QUADS:
+      case QUADS:
         // Quads have been broken up into two triangles by `vertex()`:
         // 0   3--5
         // | \  \ |
@@ -224,7 +225,7 @@ export class ShapeBuilder {
           res.push([i + 5, i]);
         }
         break;
-      case constants.QUAD_STRIP:
+      case QUAD_STRIP:
         // 0---2---4
         // |   |   |
         // 1---3---5
@@ -260,7 +261,7 @@ export class ShapeBuilder {
    */
   _tesselateShape() {
     // TODO: handle non-PATH shape modes that have contours
-    this.shapeMode = constants.TRIANGLES;
+    this.shapeMode = TRIANGLES;
     // const contours = [[]];
     const contours = [];
     for (let i = 0; i < this.geometry.vertices.length; i++) {
@@ -481,4 +482,6 @@ export class ShapeBuilder {
 
     return triangleVerts;
   }
-};
+}
+
+export { ShapeBuilder };