@autumnsgrove/gossamer 0.1.0 → 0.1.1

package/dist/index.js

@@ -16,6 +16,8 @@ class GossamerRenderer {
     this.animationId = null;
     this.lastFrameTime = 0;
     this.isRunning = false;
+    this.charAtlas = null;
+    this.atlasCharacters = "";
     const context = canvas.getContext("2d");
     if (!context) {
       throw new Error("Failed to get 2D rendering context");
@@ -27,6 +29,43 @@ class GossamerRenderer {
       ...config
     };
     this.setupCanvas();
+    this.buildCharacterAtlas();
+  }
+  /**
+   * Build character texture atlas for fast rendering
+   * Pre-renders all characters to an offscreen canvas, then uses drawImage
+   * instead of fillText for 5-10x faster rendering
+   */
+  buildCharacterAtlas() {
+    const { characters, cellWidth, cellHeight, color, fontFamily } = this.config;
+    if (this.atlasCharacters === characters && this.charAtlas) {
+      return;
+    }
+    const atlasWidth = characters.length * cellWidth;
+    const atlasHeight = cellHeight;
+    if (typeof OffscreenCanvas !== "undefined") {
+      this.charAtlas = new OffscreenCanvas(atlasWidth, atlasHeight);
+    } else {
+      this.charAtlas = document.createElement("canvas");
+      this.charAtlas.width = atlasWidth;
+      this.charAtlas.height = atlasHeight;
+    }
+    const ctx = this.charAtlas.getContext("2d");
+    if (!ctx) {
+      this.charAtlas = null;
+      return;
+    }
+    ctx.clearRect(0, 0, atlasWidth, atlasHeight);
+    ctx.fillStyle = color;
+    ctx.font = `${cellHeight}px ${fontFamily}`;
+    ctx.textBaseline = "top";
+    for (let i = 0; i < characters.length; i++) {
+      const char = characters[i];
+      if (char !== " ") {
+        ctx.fillText(char, i * cellWidth, 0);
+      }
+    }
+    this.atlasCharacters = characters;
   }
   /**
    * Set up the canvas with optimal rendering settings
@@ -42,8 +81,13 @@ class GossamerRenderer {
    * Update the renderer configuration
    */
   updateConfig(config) {
+    const needsAtlasRebuild = config.characters !== void 0 || config.color !== void 0 || config.cellWidth !== void 0 || config.cellHeight !== void 0 || config.fontFamily !== void 0;
     this.config = { ...this.config, ...config };
     this.setupCanvas();
+    if (needsAtlasRebuild) {
+      this.atlasCharacters = "";
+      this.buildCharacterAtlas();
+    }
   }
   /**
    * Resize the canvas to match new dimensions
@@ -135,6 +179,95 @@ class GossamerRenderer {
       }
     }
   }
+  /**
+   * PERFORMANCE: Render from BrightnessBuffer using texture atlas
+   *
+   * Uses pre-rendered character sprites instead of fillText calls.
+   * 5-10x faster than renderFromBrightnessGrid for large canvases.
+   *
+   * @param buffer - BrightnessBuffer from fillBrightnessBuffer
+   */
+  renderFromBuffer(buffer) {
+    const { characters, cellWidth, cellHeight } = this.config;
+    this.clear();
+    if (!this.charAtlas) {
+      this.ctx.fillStyle = this.config.color;
+      const charLen2 = characters.length - 1;
+      let idx2 = 0;
+      for (let row = 0; row < buffer.rows; row++) {
+        for (let col = 0; col < buffer.cols; col++) {
+          const brightness = buffer.data[idx2++];
+          const charIndex = brightness / 255 * charLen2 | 0;
+          const char = characters[Math.min(charIndex, charLen2)];
+          if (char !== " ") {
+            this.ctx.fillText(char, col * cellWidth, row * cellHeight);
+          }
+        }
+      }
+      return;
+    }
+    const charLen = characters.length - 1;
+    let idx = 0;
+    for (let row = 0; row < buffer.rows; row++) {
+      const y = row * cellHeight;
+      for (let col = 0; col < buffer.cols; col++) {
+        const brightness = buffer.data[idx++];
+        const charIndex = brightness / 255 * charLen | 0;
+        if (charIndex === 0 && characters[0] === " ") {
+          continue;
+        }
+        this.ctx.drawImage(
+          this.charAtlas,
+          charIndex * cellWidth,
+          0,
+          cellWidth,
+          cellHeight,
+          // source
+          col * cellWidth,
+          y,
+          cellWidth,
+          cellHeight
+          // destination
+        );
+      }
+    }
+  }
+  /**
+   * PERFORMANCE: Render brightness grid using atlas (legacy grid format)
+   *
+   * @param grid - 2D array of brightness values
+   */
+  renderGridFast(grid) {
+    const { characters, cellWidth, cellHeight } = this.config;
+    this.clear();
+    if (!this.charAtlas) {
+      this.renderFromBrightnessGrid(grid);
+      return;
+    }
+    const charLen = characters.length - 1;
+    for (let row = 0; row < grid.length; row++) {
+      const y = row * cellHeight;
+      const rowData = grid[row];
+      for (let col = 0; col < rowData.length; col++) {
+        const brightness = rowData[col];
+        const charIndex = brightness / 255 * charLen | 0;
+        if (charIndex === 0 && characters[0] === " ") {
+          continue;
+        }
+        this.ctx.drawImage(
+          this.charAtlas,
+          charIndex * cellWidth,
+          0,
+          cellWidth,
+          cellHeight,
+          col * cellWidth,
+          y,
+          cellWidth,
+          cellHeight
+        );
+      }
+    }
+  }
   /**
    * Calculate average brightness for a cell region
    */
@@ -544,6 +677,97 @@ function seededNoise2D(x, y, seed = 0) {
   const n = Math.sin(x * 12.9898 + y * 78.233 + seed) * 43758.5453;
   return n - Math.floor(n);
 }
+function cloudsPattern(x, y, time, config = DEFAULT_PATTERN_CONFIG) {
+  const { frequency, amplitude, speed } = config;
+  const drift = time * speed * 0.02;
+  const nx = x * frequency * 0.5 + drift;
+  const ny = y * frequency * 0.5 + drift * 0.7;
+  const base = fbmNoise(nx, ny, 5, 0.6);
+  const detail = fbmNoise(nx * 2 + drift * 0.5, ny * 2 - drift * 0.3, 3, 0.5) * 0.3;
+  const combined = base + detail;
+  return Math.tanh(combined * 1.5) * amplitude;
+}
+function plasmaPattern(x, y, time, config = DEFAULT_PATTERN_CONFIG) {
+  const { frequency, amplitude, speed } = config;
+  const t = time * speed;
+  const v1 = Math.sin(x * frequency + t);
+  const v2 = Math.sin(y * frequency + t * 0.7);
+  const v3 = Math.sin((x + y) * frequency * 0.5 + t * 0.5);
+  const v4 = Math.sin(Math.sqrt(x * x + y * y) * frequency * 0.3 + t * 0.8);
+  const cx = x - 40;
+  const cy = y - 20;
+  const v5 = Math.sin(Math.atan2(cy, cx) * 3 + t * 0.4);
+  return (v1 + v2 + v3 + v4 + v5) / 5 * amplitude;
+}
+function vortexPattern(x, y, centerX, centerY, time, config = DEFAULT_PATTERN_CONFIG) {
+  const { frequency, amplitude, speed } = config;
+  const dx = x - centerX;
+  const dy = y - centerY;
+  const distance = Math.sqrt(dx * dx + dy * dy);
+  const angle = Math.atan2(dy, dx);
+  const spiral = angle + distance * frequency * 0.1 - time * speed;
+  const turbulence = perlinNoise2D(distance * 0.1, time * speed * 0.5) * 0.3;
+  return (Math.sin(spiral * 3) + turbulence) * amplitude;
+}
+function matrixPattern(x, y, time, config = DEFAULT_PATTERN_CONFIG) {
+  const { frequency, amplitude, speed } = config;
+  const columnSeed = seededNoise2D(x, 0, 42);
+  const columnSpeed = 0.5 + columnSeed * 1.5;
+  const columnPhase = columnSeed * 100;
+  const fallPosition = (y * frequency + time * speed * columnSpeed + columnPhase) % 20;
+  const headBrightness = fallPosition < 1 ? 1 : 0;
+  const trailLength = 8;
+  const trailBrightness = fallPosition < trailLength ? Math.pow(1 - fallPosition / trailLength, 2) : 0;
+  const flicker = seededNoise2D(x, Math.floor(time * 10), y) * 0.2;
+  const value = Math.max(headBrightness, trailBrightness) + flicker;
+  return (value * 2 - 1) * amplitude;
+}
+function gradientPattern(x, y, cols, rows, time, config = DEFAULT_PATTERN_CONFIG) {
+  const { frequency, amplitude, speed } = config;
+  const nx = x / cols;
+  const ny = y / rows;
+  const angle = time * speed * 0.2;
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  const rotated = nx * cos + ny * sin;
+  const distortion = Math.sin(ny * Math.PI * 2 * frequency + time * speed) * 0.1;
+  const value = (rotated + distortion) * 2 - 1;
+  return Math.sin(value * Math.PI) * amplitude;
+}
+function diamondPattern(x, y, time, config = DEFAULT_PATTERN_CONFIG) {
+  const { frequency, amplitude, speed } = config;
+  const t = time * speed;
+  const wave1 = Math.sin((Math.abs(x - 40) + Math.abs(y - 20)) * frequency + t);
+  const wave2 = Math.sin((Math.abs(x - 40) - Math.abs(y - 20)) * frequency * 0.7 - t * 0.8);
+  const angle = t * 0.1;
+  const rx = x * Math.cos(angle) - y * Math.sin(angle);
+  const ry = x * Math.sin(angle) + y * Math.cos(angle);
+  const wave3 = Math.sin((Math.abs(rx) + Math.abs(ry)) * frequency * 0.5 + t * 0.5);
+  return (wave1 + wave2 + wave3) / 3 * amplitude;
+}
+function fractalPattern(x, y, cols, rows, time, config = DEFAULT_PATTERN_CONFIG) {
+  const { frequency, amplitude, speed } = config;
+  const scale = 3.5 * frequency;
+  const zx = x / cols * scale - scale / 2 + Math.sin(time * speed * 0.1) * 0.2;
+  const zy = y / rows * scale - scale / 2 + Math.cos(time * speed * 0.1) * 0.2;
+  const cx = -0.7 + Math.sin(time * speed * 0.05) * 0.1;
+  const cy = 0.27 + Math.cos(time * speed * 0.07) * 0.1;
+  let zrx = zx;
+  let zry = zy;
+  const maxIter = 20;
+  let iter = 0;
+  while (zrx * zrx + zry * zry < 4 && iter < maxIter) {
+    const tmp = zrx * zrx - zry * zry + cx;
+    zry = 2 * zrx * zry + cy;
+    zrx = tmp;
+    iter++;
+  }
+  if (iter === maxIter) {
+    return -1 * amplitude;
+  }
+  const smooth = iter - Math.log2(Math.log2(zrx * zrx + zry * zry));
+  return (smooth / maxIter * 2 - 1) * amplitude;
+}
 function generateBrightnessGrid(cols, rows, pattern, time = 0, config = DEFAULT_PATTERN_CONFIG) {
   const grid = [];
   const { frequency, amplitude, speed } = config;
@@ -573,6 +797,29 @@ function generateBrightnessGrid(cols, rows, pattern, time = 0, config = DEFAULT_
           value = ripplePattern(col, row, cols / 2, rows / 2, time, config);
           break;
         case "static":
+          value = seededNoise2D(col, row, Math.floor(time * speed * 10)) * 2 - 1;
+          break;
+        case "clouds":
+          value = cloudsPattern(col, row, time, config);
+          break;
+        case "plasma":
+          value = plasmaPattern(col, row, time, config);
+          break;
+        case "vortex":
+          value = vortexPattern(col, row, cols / 2, rows / 2, time, config);
+          break;
+        case "matrix":
+          value = matrixPattern(col, row, time, config);
+          break;
+        case "gradient":
+          value = gradientPattern(col, row, cols, rows, time, config);
+          break;
+        case "diamond":
+          value = diamondPattern(col, row, time, config);
+          break;
+        case "fractal":
+          value = fractalPattern(col, row, cols, rows, time, config);
+          break;
         default:
           value = seededNoise2D(col, row, Math.floor(time * speed * 10)) * 2 - 1;
           break;
@@ -607,6 +854,77 @@ function gridToImageData(grid, cellWidth, cellHeight) {
   }
   return new ImageData(data, width, height);
 }
+function createBrightnessBuffer(cols, rows) {
+  return {
+    data: new Uint8Array(cols * rows),
+    cols,
+    rows
+  };
+}
+function fillBrightnessBuffer(buffer, pattern, time = 0, config = DEFAULT_PATTERN_CONFIG) {
+  const { data, cols, rows } = buffer;
+  const { frequency, amplitude, speed } = config;
+  let idx = 0;
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < cols; col++) {
+      let value;
+      switch (pattern) {
+        case "perlin":
+          value = perlinNoise2D(
+            col * frequency + time * speed * 0.1,
+            row * frequency + time * speed * 0.05
+          );
+          break;
+        case "fbm":
+          value = fbmNoise(
+            col * frequency + time * speed * 0.1,
+            row * frequency + time * speed * 0.05,
+            4,
+            0.5
+          );
+          break;
+        case "waves":
+          value = wavePattern(col, row, time, config);
+          break;
+        case "ripple":
+          value = ripplePattern(col, row, cols / 2, rows / 2, time, config);
+          break;
+        case "static":
+          value = seededNoise2D(col, row, Math.floor(time * speed * 10)) * 2 - 1;
+          break;
+        case "clouds":
+          value = cloudsPattern(col, row, time, config);
+          break;
+        case "plasma":
+          value = plasmaPattern(col, row, time, config);
+          break;
+        case "vortex":
+          value = vortexPattern(col, row, cols / 2, rows / 2, time, config);
+          break;
+        case "matrix":
+          value = matrixPattern(col, row, time, config);
+          break;
+        case "gradient":
+          value = gradientPattern(col, row, cols, rows, time, config);
+          break;
+        case "diamond":
+          value = diamondPattern(col, row, time, config);
+          break;
+        case "fractal":
+          value = fractalPattern(col, row, cols, rows, time, config);
+          break;
+        default:
+          value = seededNoise2D(col, row, Math.floor(time * speed * 10)) * 2 - 1;
+          break;
+      }
+      const normalized = (value + 1) * 0.5 * amplitude;
+      data[idx++] = normalized * 255 | 0;
+    }
+  }
+}
+function getBufferValue(buffer, col, row) {
+  return buffer.data[row * buffer.cols + col];
+}
 const CHARACTER_SETS = {
   standard: {
     name: "Standard",
@@ -679,6 +997,53 @@ const CHARACTER_SETS = {
     description: "Mathematical symbols",
     characters: " +-×÷=≠≈∞",
     bestFor: ["abstract patterns", "tech themes", "decorative"]
+  },
+  // ==========================================================================
+  // GLASS-OPTIMIZED CHARACTER SETS
+  // Designed for subtle overlays on Glass components
+  // More characters = more visible gradations
+  // ==========================================================================
+  "glass-dots": {
+    name: "Glass Dots",
+    description: "Soft dot gradations for glass overlays",
+    characters: " ·∘∙○•●",
+    bestFor: ["glass overlays", "subtle backgrounds", "mist effects"]
+  },
+  "glass-mist": {
+    name: "Glass Mist",
+    description: "Ethereal mist effect for glass",
+    characters: " .·∙•◦○◉●",
+    bestFor: ["glass overlays", "fog effects", "ambient backgrounds"]
+  },
+  "glass-dust": {
+    name: "Glass Dust",
+    description: "Floating dust particles",
+    characters: " ˙·∘°•◦○",
+    bestFor: ["glass overlays", "particle effects", "light scatter"]
+  },
+  "glass-soft": {
+    name: "Glass Soft",
+    description: "Soft block gradations for glass",
+    characters: " ·░▒▓",
+    bestFor: ["glass overlays", "soft gradients", "frosted effect"]
+  },
+  "glass-sparkle": {
+    name: "Glass Sparkle",
+    description: "Subtle sparkles for glass",
+    characters: " ·.✧✦✫★",
+    bestFor: ["glass overlays", "highlight effects", "magical themes"]
+  },
+  "glass-wave": {
+    name: "Glass Wave",
+    description: "Flowing wave patterns for glass",
+    characters: " .~∼≈≋",
+    bestFor: ["glass overlays", "water effects", "flowing motion"]
+  },
+  "glass-organic": {
+    name: "Glass Organic",
+    description: "Natural, organic feel for glass",
+    characters: " .·:;∘○◦•●",
+    bestFor: ["glass overlays", "nature themes", "grove aesthetic"]
   }
 };
 function getCharacterSet(name) {
@@ -707,6 +1072,162 @@ function validateCharacterSet(characters) {
 function invertCharacters(characters) {
   return characters.split("").reverse().join("");
 }
+const GROVE_GREEN = {
+  50: { hex: "#f0fdf4", name: "Grove Green 50", glassOpacity: 0.3 },
+  100: { hex: "#dcfce7", name: "Grove Green 100", glassOpacity: 0.25 },
+  200: { hex: "#bbf7d0", name: "Grove Green 200", glassOpacity: 0.2 },
+  300: { hex: "#86efac", name: "Grove Green 300", glassOpacity: 0.18 },
+  400: { hex: "#4ade80", name: "Grove Green 400", glassOpacity: 0.15 },
+  500: { hex: "#22c55e", name: "Grove Green 500", glassOpacity: 0.12 },
+  600: { hex: "#16a34a", name: "Grove Green 600", glassOpacity: 0.1 },
+  700: { hex: "#15803d", name: "Grove Green 700", glassOpacity: 0.1 },
+  800: { hex: "#166534", name: "Grove Green 800", glassOpacity: 0.08 },
+  900: { hex: "#14532d", name: "Grove Green 900", glassOpacity: 0.08 }
+};
+const CREAM = {
+  50: { hex: "#fefdfb", name: "Cream 50", glassOpacity: 0.4 },
+  100: { hex: "#fdfcf8", name: "Cream 100", glassOpacity: 0.35 },
+  200: { hex: "#faf8f3", name: "Cream 200", glassOpacity: 0.3 },
+  300: { hex: "#f5f2ea", name: "Cream 300", glassOpacity: 0.25 },
+  400: { hex: "#ede9de", name: "Cream 400", glassOpacity: 0.2 },
+  500: { hex: "#e2ddd0", name: "Cream 500", glassOpacity: 0.18 },
+  600: { hex: "#d4cec0", name: "Cream 600", glassOpacity: 0.15 },
+  700: { hex: "#c4bdb0", name: "Cream 700", glassOpacity: 0.12 },
+  800: { hex: "#b0a99c", name: "Cream 800", glassOpacity: 0.1 },
+  900: { hex: "#9a9387", name: "Cream 900", glassOpacity: 0.08 }
+};
+const BARK = {
+  50: { hex: "#faf7f5", name: "Bark 50", glassOpacity: 0.3 },
+  100: { hex: "#f0ebe6", name: "Bark 100", glassOpacity: 0.25 },
+  200: { hex: "#e0d5cc", name: "Bark 200", glassOpacity: 0.2 },
+  300: { hex: "#ccb59c", name: "Bark 300", glassOpacity: 0.18 },
+  400: { hex: "#b89a7a", name: "Bark 400", glassOpacity: 0.15 },
+  500: { hex: "#a57c5a", name: "Bark 500", glassOpacity: 0.12 },
+  600: { hex: "#8a6344", name: "Bark 600", glassOpacity: 0.1 },
+  700: { hex: "#6f4d39", name: "Bark 700", glassOpacity: 0.1 },
+  800: { hex: "#553a2a", name: "Bark 800", glassOpacity: 0.08 },
+  900: { hex: "#3d2914", name: "Bark 900", glassOpacity: 0.06 }
+};
+const STATUS = {
+  success: { hex: "#22c55e", name: "Success", glassOpacity: 0.12 },
+  warning: { hex: "#f59e0b", name: "Warning", glassOpacity: 0.12 },
+  error: { hex: "#dc2626", name: "Error", glassOpacity: 0.1 },
+  info: { hex: "#0ea5e9", name: "Info", glassOpacity: 0.12 }
+};
+const GROVE_COLORS = {
+  // Greens
+  grove: GROVE_GREEN[500].hex,
+  "grove-light": GROVE_GREEN[300].hex,
+  "grove-dark": GROVE_GREEN[700].hex,
+  "grove-muted": GROVE_GREEN[400].hex,
+  // Creams
+  cream: CREAM[50].hex,
+  "cream-warm": CREAM[200].hex,
+  "cream-deep": CREAM[500].hex,
+  // Barks
+  bark: BARK[900].hex,
+  "bark-light": BARK[500].hex,
+  "bark-medium": BARK[700].hex,
+  // Utility
+  white: "#ffffff",
+  black: "#000000",
+  transparent: "transparent"
+};
+const GLASS_SCHEMES = {
+  // Light mode schemes (on light backgrounds)
+  "grove-mist": {
+    color: GROVE_GREEN[500].hex,
+    background: "transparent",
+    opacity: 0.12,
+    description: "Subtle green mist for light glass"
+  },
+  "cream-haze": {
+    color: CREAM[600].hex,
+    background: "transparent",
+    opacity: 0.15,
+    description: "Warm cream haze for cozy glass"
+  },
+  "bark-shadow": {
+    color: BARK[700].hex,
+    background: "transparent",
+    opacity: 0.08,
+    description: "Soft earth shadow for depth"
+  },
+  // Dark mode schemes (on dark backgrounds)
+  "grove-glow": {
+    color: GROVE_GREEN[400].hex,
+    background: "#1a1915",
+    opacity: 0.15,
+    description: "Glowing green for dark glass"
+  },
+  "cream-dust": {
+    color: CREAM[300].hex,
+    background: "#1a1915",
+    opacity: 0.1,
+    description: "Dusty cream particles in dark"
+  },
+  "moonlight": {
+    color: "#e2e8f0",
+    background: "#1a1915",
+    opacity: 0.08,
+    description: "Cool moonlight glow"
+  },
+  // Accent schemes
+  "spring-fresh": {
+    color: GROVE_GREEN[300].hex,
+    background: "transparent",
+    opacity: 0.18,
+    description: "Fresh spring green overlay"
+  },
+  "autumn-warm": {
+    color: "#d97706",
+    background: "transparent",
+    opacity: 0.1,
+    description: "Warm autumn amber tones"
+  },
+  "winter-frost": {
+    color: "#93c5fd",
+    background: "transparent",
+    opacity: 0.12,
+    description: "Cool frost blue overlay"
+  }
+};
+function getGroveColor(name) {
+  if (name in GROVE_COLORS) {
+    return GROVE_COLORS[name];
+  }
+  if (name.startsWith("#")) {
+    return name;
+  }
+  return GROVE_COLORS.grove;
+}
+function getGlassScheme(name) {
+  if (name in GLASS_SCHEMES) {
+    const scheme = GLASS_SCHEMES[name];
+    return {
+      color: scheme.color,
+      background: scheme.background,
+      opacity: scheme.opacity
+    };
+  }
+  return {
+    color: GLASS_SCHEMES["grove-mist"].color,
+    background: GLASS_SCHEMES["grove-mist"].background,
+    opacity: GLASS_SCHEMES["grove-mist"].opacity
+  };
+}
+function getGroveColorNames() {
+  return Object.keys(GROVE_COLORS);
+}
+function getGlassSchemeNames() {
+  return Object.keys(GLASS_SCHEMES);
+}
+function hexToRgba(hex, opacity) {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return `rgba(${r}, ${g}, ${b}, ${opacity})`;
+}
 function createAnimationLoop(options) {
   const { fps = 30, onStart, onStop, onFrame } = options;
   const state = {
@@ -1244,11 +1765,17 @@ function brightnessToChar(brightness, characters = DEFAULT_CHARACTERS) {
 }
 const VERSION = "0.1.0";
 export {
+  BARK,
   CHARACTER_SETS,
+  CREAM,
   DEFAULT_CHARACTERS,
   DEFAULT_CONFIG,
   DEFAULT_PATTERN_CONFIG,
+  GLASS_SCHEMES,
+  GROVE_COLORS,
+  GROVE_GREEN,
   GossamerRenderer,
+  STATUS,
   VERSION,
   adjustBrightness,
   adjustContrast,
@@ -1258,7 +1785,9 @@ export {
   calculateFPS,
   cancelIdleCallback,
   clearCanvas,
+  cloudsPattern,
   createAnimationLoop,
+  createBrightnessBuffer,
   createCanvas,
   createCharacterSet,
   createFPSCounter,
@@ -1266,18 +1795,28 @@ export {
   createResizeObserver,
   createVisibilityObserver,
   debounce,
+  diamondPattern,
   easings,
   extractBrightness,
   fbmNoise,
+  fillBrightnessBuffer,
+  fractalPattern,
   generateBrightnessGrid,
+  getBufferValue,
   getCharacterSet,
   getCharacterSetNames,
   getCharacters,
   getDevicePixelRatio,
+  getGlassScheme,
+  getGlassSchemeNames,
+  getGroveColor,
+  getGroveColorNames,
   getImageData,
   getRecommendedFPS,
+  gradientPattern,
   gridToImageData,
   hexToRgb,
+  hexToRgba,
   imageToPixelData,
   invertCharacters,
   invertColors,
@@ -1287,10 +1826,12 @@ export {
   isOffscreenCanvasSupported,
   loadAndScaleImage,
   loadImage,
+  matrixPattern,
   measureTextWidth,
   onReducedMotionChange,
   optimizeContext,
   perlinNoise2D,
+  plasmaPattern,
   prefersReducedMotion,
   requestIdleCallback,
   resizeCanvasToContainer,
@@ -1304,6 +1845,7 @@ export {
   throttle,
   toGrayscale,
   validateCharacterSet,
+  vortexPattern,
   wavePattern
 };
 //# sourceMappingURL=index.js.map