p5 2.1.1 → 2.1.2

package/dist/type/p5.Font.js

@@ -1,15 +1,15 @@
 import { textCoreConstants } from './textCore.js';
-import { C as CENTER, R as RIGHT, a as RADIUS } from '../constants-ClrEsgSR.js';
+import { C as CENTER, R as RIGHT, a as RADIUS } from '../constants-Bt1VTUeD.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-DBmMi2eT.js';
+import '../p5.Renderer-C-tu2oim.js';
 import '../creating_reading-p2iQtNm5.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
 import '../image/filters.js';
-import '../math/p5.Vector.js';
 import '../shape/custom_shapes.js';
 import '../core/States.js';
 import '../io/utilities.js';
@@ -520,63 +520,148 @@ class Font {
   textToModel(str, x, y, width, height, options) {
     ({ width, height, options } = this._parseArgs(width, height, options));
     const extrude = options?.extrude || 0;
-    const contours = this.textToContours(str, x, y, width, height, options);
 
+    let contours = this.textToContours(str, x, y, width, height, options);
+    // Step 2: build base flat geometry - single shape
     const geom = this._pInst.buildGeometry(() => {
-      if (extrude === 0) {
-        const prevValidateFaces = this._pInst._renderer._validateFaces;
-        this._pInst._renderer._validateFaces = true;
-        this._pInst.beginShape();
-        this._pInst.normal(0, 0, 1);
-        for (const contour of contours) {
-          this._pInst.beginContour();
-          for (const { x, y } of contour) {
-            this._pInst.vertex(x, y);
-          }
-          this._pInst.endContour(this._pInst.CLOSE);
-        }
-        this._pInst.endShape();
-        this._pInst._renderer._validateFaces = prevValidateFaces;
-      } else {
-        const prevValidateFaces = this._pInst._renderer._validateFaces;
-        this._pInst._renderer._validateFaces = true;
-
-        // Draw front faces
-        for (const side of [1, -1]) {
-          this._pInst.beginShape();
-          for (const contour of contours) {
-            this._pInst.beginContour();
-            for (const { x, y } of contour) {
-              this._pInst.vertex(x, y, side * extrude * 0.5);
-            }
-            this._pInst.endContour(this._pInst.CLOSE);
-          }
-          this._pInst.endShape();
-        }
-        this._pInst._renderer._validateFaces = prevValidateFaces;
-
-        // Draw sides
-        for (const contour of contours) {
-          this._pInst.beginShape(this._pInst.QUAD_STRIP);
-          for (const v of contour) {
-            for (const side of [-1, 1]) {
-              this._pInst.vertex(v.x, v.y, side * extrude * 0.5);
-            }
-          }
-          this._pInst.endShape();
+      const prevValidateFaces = this._pInst._renderer._validateFaces;
+      this._pInst._renderer._validateFaces = true;
+
+      this._pInst.beginShape();
+      for (const contour of contours) {
+        this._pInst.beginContour();
+        for (const pt of contour) {
+          this._pInst.vertex(pt.x, pt.y, 0);
         }
+        this._pInst.endContour(this._pInst.CLOSE);
       }
+
+      this._pInst.endShape(this._pInst.CLOSE);
+
+      this._pInst._renderer._validateFaces = prevValidateFaces;
     });
-    if (extrude !== 0) {
-      geom.computeNormals();
-      for (const face of geom.faces) {
-        if (face.every(idx => geom.vertices[idx].z <= -extrude * 0.5 + 0.1)) {
-          for (const idx of face) geom.vertexNormals[idx].set(0, 0, -1);
-          face.reverse();
-        }
+
+    if (extrude === 0) {
+      return geom;
+    }
+
+    // The tessellation process creates separate vertices for each triangle,
+    // even when they share the same position. We need to deduplicate them
+    // to find which faces are actually connected, so we can identify the
+    // outer edges for extrusion.
+
+    const vertexIndices = {};
+    const vertexId = v => `${v.x.toFixed(6)}-${v.y.toFixed(6)}-${v.z.toFixed(6)}`;
+    const newVertices = [];
+    const newVertexIndex = [];
+
+    for (const v of geom.vertices) {
+      const id = vertexId(v);
+      if (!(id in vertexIndices)) {
+        const index = newVertices.length;
+        vertexIndices[id] = index;
+        newVertices.push(v.copy());
+      }
+      newVertexIndex.push(vertexIndices[id]);
+    }
+
+    // Remap faces to use deduplicated vertices
+    const newFaces = geom.faces.map(f => f.map(i => newVertexIndex[i]));
+
+    //Find outer edges (edges that appear in only one face)
+    const seen = {};
+    for (const face of newFaces) {
+      for (let off = 0; off < face.length; off++) {
+        const a = face[off];
+        const b = face[(off + 1) % face.length];
+        const id = `${Math.min(a, b)}-${Math.max(a, b)}`;
+        if (!seen[id]) seen[id] = [];
+        seen[id].push([a, b]);
+      }
+    }
+    const validEdges = [];
+    for (const key in seen) {
+      if (seen[key].length === 1) {
+        validEdges.push(seen[key][0]);
+      }
+    }
+
+    // Step 5: Create extruded geometry
+    const extruded = this._pInst.buildGeometry(() => {});
+    const half = extrude * 0.5;
+    extruded.vertices = [];
+    extruded.faces = [];
+    extruded.edges = []; // INITIALIZE EDGES ARRAY
+
+    // Add side face vertices (separate for each edge for flat shading)
+    for (const [a, b] of validEdges) {
+      const vA = newVertices[a];
+      const vB = newVertices[b];
+
+      // Skip if vertices are too close (degenerate edge)
+      // We only need to check the perimeter edge length since the other edge
+      // is the extrude direction, which is always > 0 for extruded geometry
+
+      const edgeVector = new Vector(vB.x - vA.x, vB.y - vA.y, vB.z - vA.z);
+      const extrudeVector = new Vector(0, 0, extrude);
+      const crossProduct = Vector.cross(edgeVector, extrudeVector);
+      const dist = edgeVector.mag();
+      if (crossProduct.mag() < 0.0001 || dist < 0.0001) continue;
+      // Front face vertices
+      const frontA = extruded.vertices.length;
+      extruded.vertices.push(new Vector(vA.x, vA.y, vA.z + half));
+      const frontB = extruded.vertices.length;
+      extruded.vertices.push(new Vector(vB.x, vB.y, vB.z + half));
+      const backA = extruded.vertices.length;
+      extruded.vertices.push(new Vector(vA.x, vA.y, vA.z - half));
+      const backB = extruded.vertices.length;
+      extruded.vertices.push(new Vector(vB.x, vB.y, vB.z - half));
+
+      extruded.faces.push([frontA, backA, backB]);
+      extruded.faces.push([frontA, backB, frontB]);
+      extruded.edges.push([frontA, frontB]);
+      extruded.edges.push([backA, backB]);
+      extruded.edges.push([frontA, backA]);
+      extruded.edges.push([frontB, backB]);
+    }
+
+    // Add front face (with unshared vertices for flat shading)
+    const frontVertexOffset = extruded.vertices.length;
+    for (const v of newVertices) {
+      extruded.vertices.push(new Vector(v.x, v.y, v.z + half));
+    }
+    for (const face of newFaces) {
+      if (face.length < 3) continue;
+      const mappedFace = face.map(i => i + frontVertexOffset);
+      extruded.faces.push(mappedFace);
+
+      // ADD EDGES FOR FRONT FACE
+      for (let i = 0; i < mappedFace.length; i++) {
+        const nextIndex = (i + 1) % mappedFace.length;
+        extruded.edges.push([mappedFace[i], mappedFace[nextIndex]]);
+      }
+    }
+
+    // Add back face (reversed winding order)
+    const backVertexOffset = extruded.vertices.length;
+    for (const v of newVertices) {
+      extruded.vertices.push(new Vector(v.x, v.y, v.z - half));
+    }
+
+    for (const face of newFaces) {
+      if (face.length < 3) continue;
+      const mappedFace = [...face].reverse().map(i => i + backVertexOffset);
+      extruded.faces.push(mappedFace);
+
+      // ADD EDGES FOR BACK FACE
+      for (let i = 0; i < mappedFace.length; i++) {
+        const nextIndex = (i + 1) % mappedFace.length;
+        extruded.edges.push([mappedFace[i], mappedFace[nextIndex]]);
       }
     }
-    return geom;
+
+    extruded.computeNormals();
+    return extruded;
   }
 
   variations() {
@@ -629,25 +714,14 @@ class Font {
 
   /////////////////////////////// HELPERS ////////////////////////////////
 
-  _verticalAlign(size) {
-    const { sCapHeight } = this.data?.['OS/2'] || {};
-    const { unitsPerEm = 1000 } = this.data?.head || {};
-    const { ascender = 0, descender = 0 } = this.data?.hhea || {};
-    const current = ascender / 2;
-    const target = (sCapHeight || (ascender + descender)) / 2;
-    const offset = target - current;
-    return offset * size / unitsPerEm;
-  }
-
   /*
     Returns an array of line objects, each containing { text, x, y, glyphs: [ {g, path} ] }
   */
   _lineateAndPathify(str, x, y, width, height, options = {}) {
 
     let renderer = options?.graphics?._renderer || this._pInst._renderer;
-
-    // save the baseline
-    let setBaseline = renderer.drawingContext.textBaseline;
+    renderer.push();
+    renderer.textFont(this);
 
     // lineate and compute bounds for the text
     let { lines, bounds } = renderer._computeBounds
@@ -664,8 +738,7 @@ class Font {
     const axs = this._currentAxes(renderer);
     let pathsForLine = lines.map(l => this._lineToGlyphs(l, { scale, axs }));
 
-    // restore the baseline
-    renderer.drawingContext.textBaseline = setBaseline;
+    renderer.pop();
 
     return pathsForLine;
   }
@@ -749,7 +822,7 @@ class Font {
 
   _position(renderer, lines, bounds, width, height) {
 
-    let { textAlign, textLeading } = renderer.states;
+    let { textAlign, textLeading, textSize } = renderer.states;
     let metrics = this._measureTextDefault(renderer, 'X');
     let ascent = metrics.fontBoundingBoxAscent;
 
@@ -1342,7 +1415,8 @@ function font(p5, fn) {
    * <code>
    * // Some other forms of loading fonts:
    * loadFont("https://fonts.googleapis.com/css2?family=Bricolage+Grotesque:opsz,wght@12..96,200..800&display=swap");
-   * loadFont(`@font-face { font-family: "Bricolage Grotesque", serif; font-optical-sizing: auto; font-weight: 400; font-style: normal; font-variation-settings: "wdth" 100; }`);
+   *
+   * loadFont('@font-face { font-family: "Bricolage Grotesque", serif; font-optical-sizing: auto; font-weight: 400; font-style: normal; font-variation-settings: "wdth" 100; }');
    * </code>
    * </div>
    */
@@ -1371,7 +1445,15 @@ function font(p5, fn) {
     let isCSS = path.includes('@font-face');
 
     if (!isCSS) {
-      const info = await fetch(path, { method: 'HEAD' });
+      let info;
+      try {
+        info = await fetch(path, { method: 'HEAD' });
+      } catch (e) {
+        // Sometimes files fail when requested with HEAD. Fallback to a
+        // regular GET. It loads more data, but at least then it's cached
+        // for the likely case when we have to fetch the whole thing.
+        info = await fetch(path);
+      }
       const isCSSFile = info.headers.get('content-type')?.startsWith('text/css');
       if (isCSSFile) {
         isCSS = true;

package/dist/type/textCore.js

@@ -1,8 +1,8 @@
-import { R as Renderer } from '../p5.Renderer-DBmMi2eT.js';
+import { R as Renderer } from '../p5.Renderer-C-tu2oim.js';
 import '../creating_reading-p2iQtNm5.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
-import '../constants-ClrEsgSR.js';
+import '../constants-Bt1VTUeD.js';
 import '../image/filters.js';
 import '../math/p5.Vector.js';
 import '../shape/custom_shapes.js';
@@ -1916,23 +1916,15 @@ function textCore(p5, fn) {
     let boxes = lines.map((line, i) => this[type].bind(this)
     (line, x, y + i * textLeading));
 
-    // adjust the bounding boxes based on horiz. text alignment
-    if (lines.length > 1) {
-      // When width is not provided (e.g., fontBounds path), fall back to the widest line.
-      const maxWidth = boxes.reduce((m, b) => Math.max(m, b.w || 0), 0);
-
-      boxes.forEach((bb) => {
-          const w = (width ?? maxWidth);
-          bb.x += p5.Renderer2D.prototype._xAlignOffset.call(this, textAlign, w);
-        });
+    if (lines.length > 1 && typeof width !== 'undefined') { // fix for #7984
+      // adjust the bounding boxes for horizontal text alignment in 2d
+      // the WebGL mode version does additional alignment adjustments
+      boxes.forEach(bb => bb.x += p5.Renderer2D.prototype._xAlignOffset.call(this, textAlign, width));
     }
 
-    // adjust the bounding boxes based on vert. text alignment
-    if (typeof height !== 'undefined') {
-      // Call the 2D mode version: the WebGL mode version does additional
-      // alignment adjustments to account for how WebGL renders text.
-      p5.Renderer2D.prototype._yAlignOffset.call(this, boxes, height);
-    }
+    // adjust the bounding boxes for vertical text alignment in 2d
+    // the WebGL mode version does additional alignment adjustments
+    p5.Renderer2D.prototype._yAlignOffset.call(this, boxes, height || 0); // fix for #7984
 
     // get the bounds for the text block
     let bounds = boxes[0];
@@ -2502,6 +2494,21 @@ function textCore(p5, fn) {
     return this._pInst;
   };
 
+  Renderer.prototype._middleAlignOffset = function() {
+    const { textFont, textSize } = this.states;
+    const font = textFont?.font;
+    const ctx = this.textDrawingContext();
+    const metrics = ctx.measureText('X');
+    let sCapHeight = (font?.data || {})['OS/2']?.sCapHeight;
+    if (sCapHeight) {
+      const unitsPerEm = font.data.head.unitsPerEm;
+      sCapHeight *= textSize / unitsPerEm;
+    } else {
+      sCapHeight = metrics.fontBoundingBoxAscent;
+    }
+    return metrics.alphabeticBaseline + sCapHeight / 2;
+  };
+
   if (p5.Renderer2D) {
     p5.Renderer2D.prototype.textCanvas = function () {
       return this.canvas;
@@ -2591,7 +2598,7 @@ function textCore(p5, fn) {
         case fn.BASELINE:
           break;
         case textCoreConstants._CTX_MIDDLE:
-          yOff = ydiff / 2;
+          yOff = ydiff / 2 + this._middleAlignOffset();
           break;
         case fn.BOTTOM:
           yOff = ydiff;
@@ -2609,7 +2616,7 @@ function textCore(p5, fn) {
   }
 
   if (p5.RendererGL) {
-    p5.RendererGL.prototype.textCanvas = function() {
+    p5.RendererGL.prototype.textCanvas = function () {
       if (!this._textCanvas) {
         this._textCanvas = document.createElement('canvas');
         this._textCanvas.width = 1;
@@ -2620,7 +2627,7 @@ function textCore(p5, fn) {
       }
       return this._textCanvas;
     };
-    p5.RendererGL.prototype.textDrawingContext = function() {
+    p5.RendererGL.prototype.textDrawingContext = function () {
       if (!this._textDrawingContext) {
         const textCanvas = this.textCanvas();
         this._textDrawingContext = textCanvas.getContext('2d');
@@ -2628,7 +2635,7 @@ function textCore(p5, fn) {
       return this._textDrawingContext;
     };
     const oldRemove = p5.RendererGL.prototype.remove;
-    p5.RendererGL.prototype.remove = function() {
+    p5.RendererGL.prototype.remove = function () {
       if (this._textCanvas) {
         this._textCanvas.parentElement.removeChild(this._textCanvas);
       }
@@ -2672,6 +2679,13 @@ function textCore(p5, fn) {
       return this._yAlignOffset(lineData, adjustedH);
     };
 
+    p5.RendererGL.prototype._verticalAlignFont = function() {
+      const ctx = this.textDrawingContext();
+      const metrics = ctx.measureText('X');
+      return -metrics.alphabeticBaseline ||
+        (-metrics.fontBoundingBoxAscent + metrics.fontBoundingBoxDescent);
+    };
+
     p5.RendererGL.prototype._yAlignOffset = function (dataArr, height) {
 
       if (typeof height === 'undefined') {
@@ -2684,12 +2698,12 @@ function textCore(p5, fn) {
         ((textLeading - textSize) * (numLines - 1));
       switch (textBaseline) { // drawingContext ?
         case fn.TOP:
-          yOff = textSize;
+          yOff = this._verticalAlignFont();
           break;
         case fn.BASELINE:
           break;
         case textCoreConstants._CTX_MIDDLE:
-          yOff = -totalHeight / 2 + textSize + (height || 0) / 2;
+          yOff = (-totalHeight + textSize + (height || 0)) / 2 + this._verticalAlignFont() + this._middleAlignOffset();
           break;
         case fn.BOTTOM:
           yOff = -(totalHeight - textSize) + (height || 0);
@@ -2698,7 +2712,6 @@ function textCore(p5, fn) {
           console.warn(`${textBaseline} is not supported in WebGL mode.`); // FES?
           break;
       }
-      yOff += this.states.textFont.font?._verticalAlign(textSize) || 0; // Does this function exist?
       dataArr.forEach(ele => ele.y += yOff);
       return dataArr;
     };

package/dist/webgl/3d_primitives.js

@@ -1,5 +1,5 @@
-import '../constants-ClrEsgSR.js';
-export { p as default } from '../rendering-CEHgvKUS.js';
+import '../constants-Bt1VTUeD.js';
+export { p as default } from '../rendering-COLWmJqb.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-DBmMi2eT.js';
+import '../p5.Renderer-C-tu2oim.js';
 import '../image/filters.js';
 import '../shape/custom_shapes.js';
 import '../core/States.js';

package/dist/webgl/GeometryBuilder.js

@@ -1,4 +1,4 @@
-import { r as TRIANGLE_STRIP, s as QUAD_STRIP, q as TRIANGLE_FAN, p as TRIANGLES } from '../constants-ClrEsgSR.js';
+import { r as TRIANGLE_STRIP, s as QUAD_STRIP, q as TRIANGLE_FAN, p as TRIANGLES } from '../constants-Bt1VTUeD.js';
 import '../math/p5.Matrix.js';
 import { Geometry } from './p5.Geometry.js';
 import { Matrix } from '../math/Matrices/Matrix.js';

package/dist/webgl/ShapeBuilder.js

@@ -1,4 +1,4 @@
-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-ClrEsgSR.js';
+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-Bt1VTUeD.js';
 import { Geometry } from './p5.Geometry.js';
 import libtess from 'libtess';
 import { Vector } from '../math/p5.Vector.js';

package/dist/webgl/index.js

@@ -1,4 +1,4 @@
-import { r as rendererGL, p as primitives3D, l as light, m as material, c as camera, f as framebuffer, s as shader, t as texture } from '../rendering-CEHgvKUS.js';
+import { r as rendererGL, p as primitives3D, l as light, m as material, c as camera, f as framebuffer, s as shader, t as texture } from '../rendering-COLWmJqb.js';
 import interaction from './interaction.js';
 import loading from './loading.js';
 import text from './text.js';
@@ -8,14 +8,14 @@ import matrix from '../math/p5.Matrix.js';
 import geometry from './p5.Geometry.js';
 import dataArray from './p5.DataArray.js';
 import strands from '../strands/p5.strands.js';
-import '../constants-ClrEsgSR.js';
+import '../constants-Bt1VTUeD.js';
 import '../creating_reading-p2iQtNm5.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-DBmMi2eT.js';
+import '../p5.Renderer-C-tu2oim.js';
 import '../image/filters.js';
 import '../math/p5.Vector.js';
 import '../shape/custom_shapes.js';
@@ -60,7 +60,7 @@ import 'escodegen';
 import '../strands/ir_cfg.js';
 import '../strands/strands_codegen.js';
 import '../strands/strands_api.js';
-import '../ir_builders-CWOp5cp1.js';
+import '../ir_builders-Cn4s8QTL.js';
 import '../strands/strands_builtins.js';
 import '../strands/strands_conditionals.js';
 import '../strands/strands_phi_utils.js';

package/dist/webgl/interaction.js

@@ -1,4 +1,4 @@
-import { G as GRID, A as AXES } from '../constants-ClrEsgSR.js';
+import { G as GRID, A as AXES } from '../constants-Bt1VTUeD.js';
 import { Vector } from '../math/p5.Vector.js';
 
 /**

package/dist/webgl/light.js

@@ -1,13 +1,13 @@
-export { l as default } from '../rendering-CEHgvKUS.js';
+export { l as default } from '../rendering-COLWmJqb.js';
 import '../math/p5.Vector.js';
 import '../creating_reading-p2iQtNm5.js';
-import '../constants-ClrEsgSR.js';
+import '../constants-Bt1VTUeD.js';
 import '../dom/p5.Element.js';
 import '../dom/p5.File.js';
 import '../io/p5.XML.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
-import '../p5.Renderer-DBmMi2eT.js';
+import '../p5.Renderer-C-tu2oim.js';
 import '../image/filters.js';
 import '../shape/custom_shapes.js';
 import '../core/States.js';

package/dist/webgl/loading.js

@@ -1,7 +1,7 @@
 import { Geometry } from './p5.Geometry.js';
 import { Vector } from '../math/p5.Vector.js';
-import { a as request } from '../rendering-CEHgvKUS.js';
-import '../constants-ClrEsgSR.js';
+import { a as request } from '../rendering-COLWmJqb.js';
+import '../constants-Bt1VTUeD.js';
 import './p5.DataArray.js';
 import '../io/utilities.js';
 import 'file-saver';
@@ -11,7 +11,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-DBmMi2eT.js';
+import '../p5.Renderer-C-tu2oim.js';
 import '../image/filters.js';
 import '../shape/custom_shapes.js';
 import '../core/States.js';

package/dist/webgl/material.js

@@ -1,12 +1,12 @@
-import '../constants-ClrEsgSR.js';
-export { m as default } from '../rendering-CEHgvKUS.js';
+import '../constants-Bt1VTUeD.js';
+export { m as default } from '../rendering-COLWmJqb.js';
 import '../creating_reading-p2iQtNm5.js';
 import '../dom/p5.Element.js';
 import '../dom/p5.File.js';
 import '../io/p5.XML.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
-import '../p5.Renderer-DBmMi2eT.js';
+import '../p5.Renderer-C-tu2oim.js';
 import '../image/filters.js';
 import '../math/p5.Vector.js';
 import '../shape/custom_shapes.js';

package/dist/webgl/p5.Camera.js

@@ -1,9 +1,9 @@
 import '../math/p5.Matrix.js';
 import '../math/p5.Vector.js';
 import './p5.Quat.js';
-export { C as Camera, c as default } from '../rendering-CEHgvKUS.js';
+export { C as Camera, c as default } from '../rendering-COLWmJqb.js';
 import '../math/Matrices/Matrix.js';
-import '../constants-ClrEsgSR.js';
+import '../constants-Bt1VTUeD.js';
 import '../math/Matrices/MatrixInterface.js';
 import '../creating_reading-p2iQtNm5.js';
 import 'colorjs.io/fn';
@@ -11,7 +11,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-DBmMi2eT.js';
+import '../p5.Renderer-C-tu2oim.js';
 import '../image/filters.js';
 import '../shape/custom_shapes.js';
 import '../core/States.js';

package/dist/webgl/p5.Framebuffer.js

@@ -1,7 +1,7 @@
-import '../constants-ClrEsgSR.js';
+import '../constants-Bt1VTUeD.js';
 import '../creating_reading-p2iQtNm5.js';
-export { H as Framebuffer, E as FramebufferCamera, F as FramebufferTexture, f as default } from '../rendering-CEHgvKUS.js';
-import '../p5.Renderer-DBmMi2eT.js';
+export { H as Framebuffer, E as FramebufferCamera, F as FramebufferTexture, f as default } from '../rendering-COLWmJqb.js';
+import '../p5.Renderer-C-tu2oim.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
 import '../dom/p5.Element.js';

package/dist/webgl/p5.Geometry.js

@@ -1,4 +1,4 @@
-import { F as FLAT, y as SMOOTH } from '../constants-ClrEsgSR.js';
+import { F as FLAT, y as SMOOTH } from '../constants-Bt1VTUeD.js';
 import { DataArray } from './p5.DataArray.js';
 import { Vector } from '../math/p5.Vector.js';
 import { downloadFile } from '../io/utilities.js';

package/dist/webgl/p5.Quat.js

@@ -1,5 +1,5 @@
 import { Vector } from '../math/p5.Vector.js';
-import '../constants-ClrEsgSR.js';
+import '../constants-Bt1VTUeD.js';
 
 /**
  * @module Math

package/dist/webgl/p5.RendererGL.js

@@ -1,8 +1,8 @@
-import '../constants-ClrEsgSR.js';
+import '../constants-Bt1VTUeD.js';
 import './GeometryBuilder.js';
-import '../p5.Renderer-DBmMi2eT.js';
+import '../p5.Renderer-C-tu2oim.js';
 import '../math/p5.Matrix.js';
-export { R as RendererGL, r as default, B as readPixelWebGL, A as readPixelsWebGL } from '../rendering-CEHgvKUS.js';
+export { R as RendererGL, r as default, B as readPixelWebGL, A as readPixelsWebGL } from '../rendering-COLWmJqb.js';
 import '../math/p5.Vector.js';
 import './p5.RenderBuffer.js';
 import './p5.DataArray.js';

package/dist/webgl/p5.Shader.js

@@ -1,12 +1,12 @@
-export { S as Shader, s as default } from '../rendering-CEHgvKUS.js';
-import '../constants-ClrEsgSR.js';
+export { S as Shader, s as default } from '../rendering-COLWmJqb.js';
+import '../constants-Bt1VTUeD.js';
 import '../creating_reading-p2iQtNm5.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-DBmMi2eT.js';
+import '../p5.Renderer-C-tu2oim.js';
 import '../image/filters.js';
 import '../math/p5.Vector.js';
 import '../shape/custom_shapes.js';

package/dist/webgl/p5.Texture.js

@@ -1,8 +1,8 @@
-import '../constants-ClrEsgSR.js';
+import '../constants-Bt1VTUeD.js';
 import '../dom/p5.Element.js';
-import '../p5.Renderer-DBmMi2eT.js';
+import '../p5.Renderer-C-tu2oim.js';
 import '../dom/p5.MediaElement.js';
-export { M as MipmapTexture, T as Texture, D as checkWebGLCapabilities, t as default } from '../rendering-CEHgvKUS.js';
+export { M as MipmapTexture, T as Texture, D as checkWebGLCapabilities, t as default } from '../rendering-COLWmJqb.js';
 import '../dom/p5.File.js';
 import '../io/p5.XML.js';
 import '../creating_reading-p2iQtNm5.js';