@autumnsgrove/gossamer 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,1851 +1,80 @@
-const DEFAULT_CHARACTERS$1 = " .:-=+*#%@";
-function calculateBrightness$1(r, g, b) {
-  return 0.21 * r + 0.72 * g + 0.07 * b;
-}
-const DEFAULT_RENDER_CONFIG = {
-  characters: DEFAULT_CHARACTERS$1,
-  cellWidth: 8,
-  cellHeight: 12,
-  color: "#ffffff",
-  backgroundColor: "",
-  fontFamily: "monospace",
-  brightnessFunction: calculateBrightness$1
-};
-class GossamerRenderer {
-  constructor(canvas, config = {}) {
-    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");
-    }
-    this.ctx = context;
-    this.config = {
-      canvas,
-      ...DEFAULT_RENDER_CONFIG,
-      ...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
-   */
-  setupCanvas() {
-    const { fontFamily, cellHeight } = this.config;
-    this.ctx.font = `${cellHeight}px ${fontFamily}`;
-    this.ctx.textBaseline = "top";
-    this.ctx.imageSmoothingEnabled = true;
-    this.ctx.imageSmoothingQuality = "high";
-  }
-  /**
-   * 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
-   */
-  resize(width, height) {
-    const { canvas } = this.config;
-    canvas.width = width;
-    canvas.height = height;
-    this.setupCanvas();
-  }
-  /**
-   * Get the current canvas dimensions
-   */
-  getDimensions() {
-    return {
-      width: this.config.canvas.width,
-      height: this.config.canvas.height
-    };
-  }
-  /**
-   * Calculate the number of cells that fit in the canvas
-   */
-  getCellCount() {
-    const { width, height } = this.getDimensions();
-    const { cellWidth, cellHeight } = this.config;
-    return {
-      cols: Math.ceil(width / cellWidth),
-      rows: Math.ceil(height / cellHeight)
-    };
-  }
-  /**
-   * Clear the canvas
-   */
-  clear() {
-    const { canvas, backgroundColor } = this.config;
-    if (backgroundColor) {
-      this.ctx.fillStyle = backgroundColor;
-      this.ctx.fillRect(0, 0, canvas.width, canvas.height);
-    } else {
-      this.ctx.clearRect(0, 0, canvas.width, canvas.height);
-    }
-  }
-  /**
-   * Render a single frame from image data
-   */
-  renderFrame(imageData) {
-    const { canvas, characters, cellWidth, cellHeight, color, brightnessFunction } = this.config;
-    const { width, data } = imageData;
-    this.clear();
-    this.ctx.fillStyle = color;
-    for (let y = 0; y < canvas.height; y += cellHeight) {
-      for (let x = 0; x < canvas.width; x += cellWidth) {
-        const brightness = this.getCellBrightness(data, x, y, width, cellWidth, cellHeight, brightnessFunction);
-        const charIndex = Math.floor(brightness / 255 * (characters.length - 1));
-        const char = characters[Math.min(charIndex, characters.length - 1)];
-        if (char !== " ") {
-          this.ctx.fillText(char, x, y);
-        }
-      }
-    }
-  }
-  /**
-   * Render ASCII from a brightness grid (for pattern-based rendering)
-   */
-  renderFromBrightnessGrid(grid) {
-    const { characters, cellWidth, cellHeight, color } = this.config;
-    this.clear();
-    this.ctx.fillStyle = color;
-    for (let row = 0; row < grid.length; row++) {
-      for (let col = 0; col < grid[row].length; col++) {
-        const brightness = grid[row][col];
-        const charIndex = Math.floor(brightness / 255 * (characters.length - 1));
-        const char = characters[Math.min(charIndex, characters.length - 1)];
-        if (char !== " ") {
-          this.ctx.fillText(char, col * cellWidth, row * cellHeight);
-        }
-      }
-    }
-  }
-  /**
-   * Render ASCII with per-cell colors (for colored image rendering)
-   */
-  renderWithColors(data) {
-    this.clear();
-    for (const { char, color, x, y } of data) {
-      if (char !== " ") {
-        this.ctx.fillStyle = color;
-        this.ctx.fillText(char, x, y);
-      }
-    }
-  }
-  /**
-   * 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
-   */
-  getCellBrightness(data, startX, startY, imageWidth, cellWidth, cellHeight, brightnessFunction) {
-    let total = 0;
-    let count = 0;
-    for (let cy = 0; cy < cellHeight; cy++) {
-      for (let cx = 0; cx < cellWidth; cx++) {
-        const px = ((startY + cy) * imageWidth + (startX + cx)) * 4;
-        if (px >= 0 && px + 2 < data.length) {
-          total += brightnessFunction(data[px], data[px + 1], data[px + 2]);
-          count++;
-        }
-      }
-    }
-    return count > 0 ? total / count : 0;
-  }
-  /**
-   * Start an animation loop with FPS limiting
-   */
-  startAnimation(updateFn, fps = 30) {
-    if (this.isRunning) {
-      this.stopAnimation();
-    }
-    this.isRunning = true;
-    const frameInterval = 1e3 / fps;
-    this.lastFrameTime = performance.now();
-    const animate = (currentTime) => {
-      if (!this.isRunning) return;
-      const deltaTime = currentTime - this.lastFrameTime;
-      if (deltaTime >= frameInterval) {
-        const result = updateFn(currentTime, deltaTime);
-        if (result instanceof ImageData) {
-          this.renderFrame(result);
-        } else {
-          this.renderFromBrightnessGrid(result);
-        }
-        this.lastFrameTime = currentTime - deltaTime % frameInterval;
-      }
-      this.animationId = requestAnimationFrame(animate);
-    };
-    this.animationId = requestAnimationFrame(animate);
-  }
-  /**
-   * Stop the animation loop
-   */
-  stopAnimation() {
-    this.isRunning = false;
-    if (this.animationId !== null) {
-      cancelAnimationFrame(this.animationId);
-      this.animationId = null;
-    }
-  }
-  /**
-   * Check if animation is currently running
-   */
-  isAnimating() {
-    return this.isRunning;
-  }
-  /**
-   * Pause animation (can be resumed)
-   */
-  pause() {
-    this.isRunning = false;
-    if (this.animationId !== null) {
-      cancelAnimationFrame(this.animationId);
-      this.animationId = null;
-    }
-  }
-  /**
-   * Clean up and destroy the renderer
-   */
-  destroy() {
-    this.stopAnimation();
-  }
-}
-const DEFAULT_PATTERN_CONFIG = {
-  frequency: 0.05,
-  amplitude: 1,
-  speed: 0.5
-};
-const PERMUTATION = new Uint8Array(512);
-const P = new Uint8Array([
-  151,
-  160,
-  137,
-  91,
-  90,
-  15,
-  131,
-  13,
-  201,
-  95,
-  96,
-  53,
-  194,
-  233,
-  7,
-  225,
-  140,
-  36,
-  103,
-  30,
-  69,
-  142,
-  8,
-  99,
-  37,
-  240,
-  21,
-  10,
-  23,
-  190,
-  6,
-  148,
-  247,
-  120,
-  234,
-  75,
-  0,
-  26,
-  197,
-  62,
-  94,
-  252,
-  219,
-  203,
-  117,
-  35,
-  11,
-  32,
-  57,
-  177,
-  33,
-  88,
-  237,
-  149,
-  56,
-  87,
-  174,
-  20,
-  125,
-  136,
-  171,
-  168,
-  68,
-  175,
-  74,
-  165,
-  71,
-  134,
-  139,
-  48,
-  27,
-  166,
-  77,
-  146,
-  158,
-  231,
-  83,
-  111,
-  229,
-  122,
-  60,
-  211,
-  133,
-  230,
-  220,
-  105,
-  92,
-  41,
-  55,
-  46,
-  245,
-  40,
-  244,
-  102,
-  143,
-  54,
-  65,
-  25,
-  63,
-  161,
-  1,
-  216,
-  80,
-  73,
-  209,
-  76,
-  132,
-  187,
-  208,
-  89,
-  18,
-  169,
-  200,
-  196,
-  135,
-  130,
-  116,
-  188,
-  159,
-  86,
-  164,
-  100,
-  109,
-  198,
-  173,
-  186,
-  3,
-  64,
-  52,
-  217,
-  226,
-  250,
-  124,
-  123,
-  5,
-  202,
-  38,
-  147,
-  118,
-  126,
-  255,
-  82,
-  85,
-  212,
-  207,
-  206,
-  59,
-  227,
-  47,
-  16,
-  58,
-  17,
-  182,
-  189,
-  28,
-  42,
-  223,
-  183,
-  170,
-  213,
-  119,
-  248,
-  152,
-  2,
-  44,
-  154,
-  163,
-  70,
-  221,
-  153,
-  101,
-  155,
-  167,
-  43,
-  172,
-  9,
-  129,
-  22,
-  39,
-  253,
-  19,
-  98,
-  108,
-  110,
-  79,
-  113,
-  224,
-  232,
-  178,
-  185,
-  112,
-  104,
-  218,
-  246,
-  97,
-  228,
-  251,
-  34,
-  242,
-  193,
-  238,
-  210,
-  144,
-  12,
-  191,
-  179,
-  162,
-  241,
-  81,
-  51,
-  145,
-  235,
-  249,
-  14,
-  239,
-  107,
-  49,
-  192,
-  214,
-  31,
-  181,
-  199,
-  106,
-  157,
-  184,
-  84,
-  204,
-  176,
-  115,
-  121,
-  50,
-  45,
-  127,
-  4,
-  150,
-  254,
-  138,
-  236,
-  205,
-  93,
-  222,
-  114,
-  67,
-  29,
-  24,
-  72,
-  243,
-  141,
-  128,
-  195,
-  78,
-  66,
-  215,
-  61,
-  156,
-  180
-]);
-for (let i = 0; i < 256; i++) {
-  PERMUTATION[i] = P[i];
-  PERMUTATION[i + 256] = P[i];
-}
-function fade(t) {
-  return t * t * t * (t * (t * 6 - 15) + 10);
-}
-function lerp(a, b, t) {
-  return a + t * (b - a);
-}
-function grad(hash, x, y) {
-  const h = hash & 3;
-  const u = h < 2 ? x : y;
-  const v = h < 2 ? y : x;
-  return ((h & 1) === 0 ? u : -u) + ((h & 2) === 0 ? v : -v);
-}
-function perlinNoise2D(x, y) {
-  const xi = Math.floor(x) & 255;
-  const yi = Math.floor(y) & 255;
-  const xf = x - Math.floor(x);
-  const yf = y - Math.floor(y);
-  const u = fade(xf);
-  const v = fade(yf);
-  const aa = PERMUTATION[PERMUTATION[xi] + yi];
-  const ab = PERMUTATION[PERMUTATION[xi] + yi + 1];
-  const ba = PERMUTATION[PERMUTATION[xi + 1] + yi];
-  const bb = PERMUTATION[PERMUTATION[xi + 1] + yi + 1];
-  const x1 = lerp(grad(aa, xf, yf), grad(ba, xf - 1, yf), u);
-  const x2 = lerp(grad(ab, xf, yf - 1), grad(bb, xf - 1, yf - 1), u);
-  return lerp(x1, x2, v);
-}
-function fbmNoise(x, y, octaves = 4, persistence = 0.5) {
-  let total = 0;
-  let frequency = 1;
-  let amplitude = 1;
-  let maxValue = 0;
-  for (let i = 0; i < octaves; i++) {
-    total += perlinNoise2D(x * frequency, y * frequency) * amplitude;
-    maxValue += amplitude;
-    amplitude *= persistence;
-    frequency *= 2;
-  }
-  return total / maxValue;
-}
-function wavePattern(x, y, time, config = DEFAULT_PATTERN_CONFIG) {
-  const { frequency, amplitude, speed } = config;
-  const wave1 = Math.sin(x * frequency + time * speed);
-  const wave2 = Math.cos(y * frequency + time * speed * 0.7);
-  const wave3 = Math.sin((x + y) * frequency * 0.5 + time * speed * 0.5);
-  return (wave1 + wave2 + wave3) / 3 * amplitude;
-}
-function ripplePattern(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);
-  return Math.sin(distance * frequency - time * speed) * amplitude;
-}
-function staticNoise(seed) {
-  if (seed !== void 0) {
-    const x = Math.sin(seed * 12.9898) * 43758.5453;
-    return x - Math.floor(x);
-  }
-  return Math.random();
-}
-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;
-  for (let row = 0; row < rows; row++) {
-    grid[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;
-      const brightness = Math.max(0, Math.min(255, Math.floor(normalized * 255)));
-      grid[row][col] = brightness;
-    }
-  }
-  return grid;
-}
-function gridToImageData(grid, cellWidth, cellHeight) {
-  var _a;
-  const rows = grid.length;
-  const cols = ((_a = grid[0]) == null ? void 0 : _a.length) || 0;
-  const width = cols * cellWidth;
-  const height = rows * cellHeight;
-  const data = new Uint8ClampedArray(width * height * 4);
-  for (let row = 0; row < rows; row++) {
-    for (let col = 0; col < cols; col++) {
-      const brightness = grid[row][col];
-      for (let cy = 0; cy < cellHeight; cy++) {
-        for (let cx = 0; cx < cellWidth; cx++) {
-          const px = ((row * cellHeight + cy) * width + (col * cellWidth + cx)) * 4;
-          data[px] = brightness;
-          data[px + 1] = brightness;
-          data[px + 2] = brightness;
-          data[px + 3] = 255;
-        }
-      }
-    }
-  }
-  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",
-    description: "Classic ASCII art character set",
-    characters: " .:-=+*#%@",
-    bestFor: ["general", "images", "patterns"]
-  },
-  dense: {
-    name: "Dense",
-    description: "High detail character set with many gradations",
-    characters: " .'`^\",:;Il!i><~+_-?][}{1)(|\\/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$",
-    bestFor: ["detailed images", "portraits", "high contrast"]
-  },
-  minimal: {
-    name: "Minimal",
-    description: "Clean and simple with few characters",
-    characters: " .:*#",
-    bestFor: ["backgrounds", "subtle effects", "clean aesthetic"]
-  },
-  grove: {
-    name: "Grove",
-    description: "Organic, soft characters inspired by nature",
-    characters: " ·∙•◦○◉●",
-    bestFor: ["organic patterns", "soft backgrounds", "nature themes"]
-  },
-  dots: {
-    name: "Dots",
-    description: "Braille-like dot patterns",
-    characters: " ⋅∘∙●",
-    bestFor: ["stipple effects", "pointillism", "dotted textures"]
-  },
-  blocks: {
-    name: "Blocks",
-    description: "Block-based characters for sharp edges",
-    characters: " ░▒▓█",
-    bestFor: ["retro effects", "pixel art", "bold patterns"]
-  },
-  lines: {
-    name: "Lines",
-    description: "Line-based characters for directional effects",
-    characters: " -─═╌│┃",
-    bestFor: ["rain effects", "streaks", "motion blur"]
-  },
-  stars: {
-    name: "Stars",
-    description: "Star and sparkle characters",
-    characters: " ·✧✦✫✬✯★",
-    bestFor: ["sparkle effects", "night sky", "magical themes"]
-  },
-  nature: {
-    name: "Nature",
-    description: "Nature-themed decorative characters",
-    characters: " .~≈∿⌇☘",
-    bestFor: ["decorative", "themed effects", "organic patterns"]
-  },
-  weather: {
-    name: "Weather",
-    description: "Weather-related symbols",
-    characters: " ·.:*❄❅❆",
-    bestFor: ["snow effects", "weather simulations", "seasonal themes"]
-  },
-  binary: {
-    name: "Binary",
-    description: "Digital-style binary characters",
-    characters: " 01",
-    bestFor: ["digital effects", "matrix style", "tech themes"]
-  },
-  math: {
-    name: "Math",
-    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) {
-  return CHARACTER_SETS[name];
-}
-function getCharacters(name) {
-  var _a;
-  return ((_a = CHARACTER_SETS[name]) == null ? void 0 : _a.characters) || CHARACTER_SETS.standard.characters;
-}
-function getCharacterSetNames() {
-  return Object.keys(CHARACTER_SETS);
-}
-function createCharacterSet(name, characters, description = "", bestFor = []) {
-  return {
-    name,
-    description,
-    characters,
-    bestFor
-  };
-}
-function validateCharacterSet(characters) {
-  if (characters.length < 2) return false;
-  if (characters[0] !== " ") return false;
-  return true;
-}
-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 = {
-    isRunning: false,
-    frameId: null,
-    lastFrameTime: 0,
-    frameInterval: 1e3 / fps,
-    elapsedTime: 0,
-    frameCount: 0
-  };
-  let pausedTime = 0;
-  let isPaused = false;
-  function animate(currentTime) {
-    if (!state.isRunning || isPaused) return;
-    const deltaTime = currentTime - state.lastFrameTime;
-    if (deltaTime >= state.frameInterval) {
-      state.elapsedTime += deltaTime;
-      state.frameCount++;
-      const continueAnimation = onFrame(currentTime, deltaTime, state.frameCount);
-      if (continueAnimation === false) {
-        stop();
-        return;
-      }
-      state.lastFrameTime = currentTime - deltaTime % state.frameInterval;
-    }
-    state.frameId = requestAnimationFrame(animate);
-  }
-  function start() {
-    if (state.isRunning) return;
-    state.isRunning = true;
-    state.lastFrameTime = performance.now();
-    state.elapsedTime = 0;
-    state.frameCount = 0;
-    isPaused = false;
-    onStart == null ? void 0 : onStart();
-    state.frameId = requestAnimationFrame(animate);
-  }
-  function stop() {
-    state.isRunning = false;
-    isPaused = false;
-    if (state.frameId !== null) {
-      cancelAnimationFrame(state.frameId);
-      state.frameId = null;
-    }
-    onStop == null ? void 0 : onStop();
-  }
-  function pause() {
-    if (!state.isRunning || isPaused) return;
-    isPaused = true;
-    pausedTime = performance.now();
-    if (state.frameId !== null) {
-      cancelAnimationFrame(state.frameId);
-      state.frameId = null;
-    }
-  }
-  function resume() {
-    if (!state.isRunning || !isPaused) return;
-    isPaused = false;
-    state.lastFrameTime += performance.now() - pausedTime;
-    state.frameId = requestAnimationFrame(animate);
-  }
-  function getState() {
-    return { ...state };
-  }
-  return { start, stop, pause, resume, getState };
-}
-function throttle(fn, limit) {
-  let lastCall = 0;
-  let timeout = null;
-  return (...args) => {
-    const now = Date.now();
-    if (now - lastCall >= limit) {
-      lastCall = now;
-      fn(...args);
-    } else if (!timeout) {
-      timeout = setTimeout(() => {
-        lastCall = Date.now();
-        timeout = null;
-        fn(...args);
-      }, limit - (now - lastCall));
-    }
-  };
-}
-function debounce(fn, delay) {
-  let timeout = null;
-  return (...args) => {
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-    timeout = setTimeout(() => {
-      timeout = null;
-      fn(...args);
-    }, delay);
-  };
-}
-function calculateFPS(frameTimes, sampleSize = 60) {
-  if (frameTimes.length < 2) return 0;
-  const samples = frameTimes.slice(-sampleSize);
-  const totalTime = samples[samples.length - 1] - samples[0];
-  const frameCount = samples.length - 1;
-  if (totalTime <= 0) return 0;
-  return frameCount / totalTime * 1e3;
-}
-const easings = {
-  /** Linear - no easing */
-  linear: (t) => t,
-  /** Ease in - slow start */
-  easeIn: (t) => t * t,
-  /** Ease out - slow end */
-  easeOut: (t) => t * (2 - t),
-  /** Ease in/out - slow start and end */
-  easeInOut: (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
-  /** Sine ease in */
-  sineIn: (t) => 1 - Math.cos(t * Math.PI / 2),
-  /** Sine ease out */
-  sineOut: (t) => Math.sin(t * Math.PI / 2),
-  /** Sine ease in/out */
-  sineInOut: (t) => -(Math.cos(Math.PI * t) - 1) / 2,
-  /** Bounce at end */
-  bounceOut: (t) => {
-    const n1 = 7.5625;
-    const d1 = 2.75;
-    if (t < 1 / d1) {
-      return n1 * t * t;
-    } else if (t < 2 / d1) {
-      return n1 * (t -= 1.5 / d1) * t + 0.75;
-    } else if (t < 2.5 / d1) {
-      return n1 * (t -= 2.25 / d1) * t + 0.9375;
-    } else {
-      return n1 * (t -= 2.625 / d1) * t + 0.984375;
-    }
-  }
-};
-function createCanvas(options = {}) {
-  const { width = 300, height = 150, highDPI = true, className, style } = options;
-  const canvas = document.createElement("canvas");
-  if (highDPI) {
-    const dpr = window.devicePixelRatio || 1;
-    canvas.width = width * dpr;
-    canvas.height = height * dpr;
-    canvas.style.width = `${width}px`;
-    canvas.style.height = `${height}px`;
-    const ctx = canvas.getContext("2d");
-    if (ctx) {
-      ctx.scale(dpr, dpr);
-    }
-  } else {
-    canvas.width = width;
-    canvas.height = height;
-  }
-  if (className) {
-    canvas.className = className;
-  }
-  if (style) {
-    Object.assign(canvas.style, style);
-  }
-  return canvas;
-}
-function getDevicePixelRatio() {
-  return typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1;
-}
-function resizeCanvasToContainer(canvas, container, highDPI = true) {
-  const rect = container.getBoundingClientRect();
-  const dpr = highDPI ? getDevicePixelRatio() : 1;
-  const width = rect.width;
-  const height = rect.height;
-  canvas.width = width * dpr;
-  canvas.height = height * dpr;
-  canvas.style.width = `${width}px`;
-  canvas.style.height = `${height}px`;
-  if (highDPI) {
-    const ctx = canvas.getContext("2d");
-    if (ctx) {
-      ctx.scale(dpr, dpr);
-    }
-  }
-  return { width, height };
-}
-function createOffscreenCanvas(width, height) {
-  if (typeof OffscreenCanvas !== "undefined") {
-    return new OffscreenCanvas(width, height);
-  }
-  const canvas = document.createElement("canvas");
-  canvas.width = width;
-  canvas.height = height;
-  return canvas;
-}
-function clearCanvas(ctx, width, height, backgroundColor) {
-  if (backgroundColor) {
-    ctx.fillStyle = backgroundColor;
-    ctx.fillRect(0, 0, width, height);
-  } else {
-    ctx.clearRect(0, 0, width, height);
-  }
-}
-function getImageData(ctx, x = 0, y = 0, width, height) {
-  const canvas = ctx.canvas;
-  const w = width ?? canvas.width;
-  const h = height ?? canvas.height;
-  return ctx.getImageData(x, y, w, h);
-}
-function optimizeContext(ctx) {
-  ctx.imageSmoothingEnabled = false;
-  ctx.globalCompositeOperation = "source-over";
-}
-function setupTextRendering(ctx, fontSize, fontFamily = "monospace", color = "#ffffff") {
-  ctx.font = `${fontSize}px ${fontFamily}`;
-  ctx.textBaseline = "top";
-  ctx.textAlign = "left";
-  ctx.fillStyle = color;
-}
-function measureTextWidth(ctx, text, fontSize, fontFamily = "monospace") {
-  const originalFont = ctx.font;
-  ctx.font = `${fontSize}px ${fontFamily}`;
-  const metrics = ctx.measureText(text);
-  ctx.font = originalFont;
-  return metrics.width;
-}
-function calculateCellSize(canvasWidth, canvasHeight, targetCols) {
-  const cellWidth = Math.floor(canvasWidth / targetCols);
-  const cellHeight = Math.floor(cellWidth * 1.5);
-  const cols = Math.floor(canvasWidth / cellWidth);
-  const rows = Math.floor(canvasHeight / cellHeight);
-  return { cellWidth, cellHeight, cols, rows };
-}
-function setBlendMode(ctx, mode) {
-  ctx.globalCompositeOperation = mode === "normal" ? "source-over" : mode;
-}
-function loadImage(src, options = {}) {
-  return new Promise((resolve, reject) => {
-    const img = new Image();
-    if (options.crossOrigin !== void 0) {
-      img.crossOrigin = options.crossOrigin;
-    }
-    img.onload = () => resolve(img);
-    img.onerror = () => reject(new Error(`Failed to load image: ${src}`));
-    img.src = src;
-  });
-}
-async function loadAndScaleImage(src, maxWidth, maxHeight, options = {}) {
-  const img = await loadImage(src, options);
-  let width = img.naturalWidth;
-  let height = img.naturalHeight;
-  if (width > maxWidth || height > maxHeight) {
-    const widthRatio = maxWidth / width;
-    const heightRatio = maxHeight / height;
-    const scale = Math.min(widthRatio, heightRatio);
-    width = Math.floor(width * scale);
-    height = Math.floor(height * scale);
-  }
-  return { image: img, width, height };
-}
-function imageToPixelData(image, width, height) {
-  const w = width ?? (image instanceof HTMLImageElement ? image.naturalWidth : image.width);
-  const h = height ?? (image instanceof HTMLImageElement ? image.naturalHeight : image.height);
-  const canvas = document.createElement("canvas");
-  canvas.width = w;
-  canvas.height = h;
-  const ctx = canvas.getContext("2d");
-  if (!ctx) {
-    throw new Error("Failed to get 2D context");
-  }
-  ctx.drawImage(image, 0, 0, w, h);
-  return ctx.getImageData(0, 0, w, h);
-}
-function extractBrightness(imageData, brightnessFunction = (r, g, b) => 0.21 * r + 0.72 * g + 0.07 * b) {
-  const { data, width, height } = imageData;
-  const brightness = new Array(width * height);
-  for (let i = 0; i < data.length; i += 4) {
-    brightness[i / 4] = brightnessFunction(data[i], data[i + 1], data[i + 2]);
-  }
-  return brightness;
-}
-function sampleImageCells(imageData, cellWidth, cellHeight, brightnessFunction = (r, g, b) => 0.21 * r + 0.72 * g + 0.07 * b) {
-  const { data, width, height } = imageData;
-  const cols = Math.ceil(width / cellWidth);
-  const rows = Math.ceil(height / cellHeight);
-  const result = [];
-  for (let row = 0; row < rows; row++) {
-    result[row] = [];
-    for (let col = 0; col < cols; col++) {
-      const cellData = sampleCell(data, width, col * cellWidth, row * cellHeight, cellWidth, cellHeight);
-      const brightness = brightnessFunction(cellData.r, cellData.g, cellData.b);
-      result[row][col] = {
-        brightness,
-        color: `rgb(${Math.round(cellData.r)}, ${Math.round(cellData.g)}, ${Math.round(cellData.b)})`
-      };
-    }
-  }
-  return result;
-}
-function sampleCell(data, imageWidth, startX, startY, cellWidth, cellHeight) {
-  let totalR = 0;
-  let totalG = 0;
-  let totalB = 0;
-  let totalA = 0;
-  let count = 0;
-  for (let y = startY; y < startY + cellHeight; y++) {
-    for (let x = startX; x < startX + cellWidth; x++) {
-      const px = (y * imageWidth + x) * 4;
-      if (px >= 0 && px + 3 < data.length) {
-        totalR += data[px];
-        totalG += data[px + 1];
-        totalB += data[px + 2];
-        totalA += data[px + 3];
-        count++;
-      }
-    }
-  }
-  if (count === 0) {
-    return { r: 0, g: 0, b: 0, a: 0 };
-  }
-  return {
-    r: totalR / count,
-    g: totalG / count,
-    b: totalB / count,
-    a: totalA / count
-  };
-}
-function rgbToHex(r, g, b) {
-  const toHex = (n) => Math.max(0, Math.min(255, Math.round(n))).toString(16).padStart(2, "0");
-  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
-}
-function hexToRgb(hex) {
-  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-  return result ? {
-    r: parseInt(result[1], 16),
-    g: parseInt(result[2], 16),
-    b: parseInt(result[3], 16)
-  } : null;
-}
-function adjustBrightness(imageData, amount) {
-  const { data, width, height } = imageData;
-  const adjusted = new Uint8ClampedArray(data.length);
-  for (let i = 0; i < data.length; i += 4) {
-    adjusted[i] = Math.min(255, Math.max(0, data[i] + amount));
-    adjusted[i + 1] = Math.min(255, Math.max(0, data[i + 1] + amount));
-    adjusted[i + 2] = Math.min(255, Math.max(0, data[i + 2] + amount));
-    adjusted[i + 3] = data[i + 3];
-  }
-  return new ImageData(adjusted, width, height);
-}
-function adjustContrast(imageData, amount) {
-  const { data, width, height } = imageData;
-  const adjusted = new Uint8ClampedArray(data.length);
-  const factor = 259 * (amount + 255) / (255 * (259 - amount));
-  for (let i = 0; i < data.length; i += 4) {
-    adjusted[i] = Math.min(255, Math.max(0, factor * (data[i] - 128) + 128));
-    adjusted[i + 1] = Math.min(255, Math.max(0, factor * (data[i + 1] - 128) + 128));
-    adjusted[i + 2] = Math.min(255, Math.max(0, factor * (data[i + 2] - 128) + 128));
-    adjusted[i + 3] = data[i + 3];
-  }
-  return new ImageData(adjusted, width, height);
-}
-function invertColors(imageData) {
-  const { data, width, height } = imageData;
-  const inverted = new Uint8ClampedArray(data.length);
-  for (let i = 0; i < data.length; i += 4) {
-    inverted[i] = 255 - data[i];
-    inverted[i + 1] = 255 - data[i + 1];
-    inverted[i + 2] = 255 - data[i + 2];
-    inverted[i + 3] = data[i + 3];
-  }
-  return new ImageData(inverted, width, height);
-}
-function toGrayscale(imageData) {
-  const { data, width, height } = imageData;
-  const grayscale = new Uint8ClampedArray(data.length);
-  for (let i = 0; i < data.length; i += 4) {
-    const gray = 0.21 * data[i] + 0.72 * data[i + 1] + 0.07 * data[i + 2];
-    grayscale[i] = gray;
-    grayscale[i + 1] = gray;
-    grayscale[i + 2] = gray;
-    grayscale[i + 3] = data[i + 3];
-  }
-  return new ImageData(grayscale, width, height);
-}
-function createVisibilityObserver(element, callback, threshold = 0.1) {
-  const observer = new IntersectionObserver(
-    (entries) => {
-      for (const entry of entries) {
-        callback(entry.isIntersecting, entry);
-      }
-    },
-    { threshold }
-  );
-  observer.observe(element);
-  return () => {
-    observer.disconnect();
-  };
-}
-function createResizeObserver(element, callback, debounceMs = 100) {
-  let timeout = null;
-  const observer = new ResizeObserver((entries) => {
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-    timeout = setTimeout(() => {
-      const entry = entries[0];
-      if (entry) {
-        const { width, height } = entry.contentRect;
-        callback(width, height, entry);
-      }
-    }, debounceMs);
-  });
-  observer.observe(element);
-  return () => {
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-    observer.disconnect();
-  };
-}
-function prefersReducedMotion() {
-  if (typeof window === "undefined") return false;
-  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
-}
-function onReducedMotionChange(callback) {
-  if (typeof window === "undefined") {
-    return () => {
-    };
-  }
-  const mediaQuery = window.matchMedia("(prefers-reduced-motion: reduce)");
-  const handler = (event) => {
-    callback(event.matches);
-  };
-  mediaQuery.addEventListener("change", handler);
-  callback(mediaQuery.matches);
-  return () => {
-    mediaQuery.removeEventListener("change", handler);
-  };
-}
-function isLowPowerMode() {
-  if (typeof navigator !== "undefined" && "getBattery" in navigator) {
-    return false;
-  }
-  if (typeof navigator !== "undefined" && navigator.hardwareConcurrency) {
-    return navigator.hardwareConcurrency <= 2;
-  }
-  return false;
-}
-function getRecommendedFPS() {
-  if (prefersReducedMotion()) {
-    return 0;
-  }
-  if (isLowPowerMode()) {
-    return 15;
-  }
-  return 30;
-}
-function createFPSCounter() {
-  const frameTimes = [];
-  const maxSamples = 60;
-  let droppedFrames = 0;
-  let lastFrameTime = performance.now();
-  function tick() {
-    const now = performance.now();
-    const delta = now - lastFrameTime;
-    lastFrameTime = now;
-    frameTimes.push(now);
-    if (frameTimes.length > maxSamples) {
-      frameTimes.shift();
-    }
-    if (delta > 20) {
-      droppedFrames += Math.floor(delta / 16.67) - 1;
-    }
-  }
-  function getFPS() {
-    if (frameTimes.length < 2) return 0;
-    const oldest = frameTimes[0];
-    const newest = frameTimes[frameTimes.length - 1];
-    const elapsed = newest - oldest;
-    if (elapsed === 0) return 0;
-    return (frameTimes.length - 1) / elapsed * 1e3;
-  }
-  function getMetrics() {
-    const fps = getFPS();
-    const frameTime = fps > 0 ? 1e3 / fps : 0;
-    return {
-      fps: Math.round(fps * 10) / 10,
-      frameTime: Math.round(frameTime * 100) / 100,
-      droppedFrames
-    };
-  }
-  function reset() {
-    frameTimes.length = 0;
-    droppedFrames = 0;
-    lastFrameTime = performance.now();
-  }
-  return { tick, getFPS, getMetrics, reset };
-}
-function requestIdleCallback(callback, options) {
-  const global = globalThis;
-  if (typeof global.requestIdleCallback === "function") {
-    return global.requestIdleCallback(callback, options);
-  }
-  return global.setTimeout(callback, (options == null ? void 0 : options.timeout) ?? 1);
-}
-function cancelIdleCallback(id) {
-  const global = globalThis;
-  if (typeof global.cancelIdleCallback === "function") {
-    global.cancelIdleCallback(id);
-  } else {
-    global.clearTimeout(id);
-  }
-}
-function isBrowser() {
-  return typeof window !== "undefined" && typeof document !== "undefined";
-}
-function isCanvasSupported() {
-  if (!isBrowser()) return false;
-  const canvas = document.createElement("canvas");
-  return !!(canvas.getContext && canvas.getContext("2d"));
-}
-function isOffscreenCanvasSupported() {
-  return typeof OffscreenCanvas !== "undefined";
-}
-const DEFAULT_CHARACTERS = " .:-=+*#%@";
-const DEFAULT_CONFIG = {
-  characters: DEFAULT_CHARACTERS,
-  cellWidth: 8,
-  cellHeight: 12,
-  color: "#ffffff",
-  backgroundColor: "",
-  fontFamily: "monospace",
-  animate: false,
-  fps: 30
-};
-function calculateBrightness(r, g, b) {
-  return 0.21 * r + 0.72 * g + 0.07 * b;
-}
-function brightnessToChar(brightness, characters = DEFAULT_CHARACTERS) {
-  const index = Math.floor(brightness / 255 * (characters.length - 1));
-  return characters[Math.min(index, characters.length - 1)];
-}
-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,
-  brightnessToChar,
-  calculateBrightness,
-  calculateCellSize,
-  calculateFPS,
-  cancelIdleCallback,
-  clearCanvas,
-  cloudsPattern,
-  createAnimationLoop,
-  createBrightnessBuffer,
-  createCanvas,
-  createCharacterSet,
-  createFPSCounter,
-  createOffscreenCanvas,
-  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,
-  isBrowser,
-  isCanvasSupported,
-  isLowPowerMode,
-  isOffscreenCanvasSupported,
-  loadAndScaleImage,
-  loadImage,
-  matrixPattern,
-  measureTextWidth,
-  onReducedMotionChange,
-  optimizeContext,
-  perlinNoise2D,
-  plasmaPattern,
-  prefersReducedMotion,
-  requestIdleCallback,
-  resizeCanvasToContainer,
-  rgbToHex,
-  ripplePattern,
-  sampleImageCells,
-  seededNoise2D,
-  setBlendMode,
-  setupTextRendering,
-  staticNoise,
-  throttle,
-  toGrayscale,
-  validateCharacterSet,
-  vortexPattern,
-  wavePattern
+/**
+ * Gossamer - ASCII Visual Effects Library
+ *
+ * Threads of light. Delicate textures woven through your space.
+ *
+ * @packageDocumentation
+ */
+// =============================================================================
+// Constants
+// =============================================================================
+/**
+ * Default character set ordered from light to dark
+ */
+export const DEFAULT_CHARACTERS = ' .:-=+*#%@';
+/**
+ * Default configuration values
+ */
+export const DEFAULT_CONFIG = {
+    characters: DEFAULT_CHARACTERS,
+    cellWidth: 8,
+    cellHeight: 12,
+    color: '#ffffff',
+    backgroundColor: '',
+    fontFamily: 'monospace',
+    animate: false,
+    fps: 30,
 };
-//# sourceMappingURL=index.js.map
+// =============================================================================
+// Core Functions
+// =============================================================================
+/**
+ * Calculate brightness from RGB values using luminance formula
+ * Uses the standard luminance coefficients: 0.21 R + 0.72 G + 0.07 B
+ */
+export function calculateBrightness(r, g, b) {
+    return 0.21 * r + 0.72 * g + 0.07 * b;
+}
+/**
+ * Map a brightness value (0-255) to an ASCII character
+ */
+export function brightnessToChar(brightness, characters = DEFAULT_CHARACTERS) {
+    const index = Math.floor((brightness / 255) * (characters.length - 1));
+    return characters[Math.min(index, characters.length - 1)];
+}
+// =============================================================================
+// Module Exports
+// =============================================================================
+// Renderer
+export { GossamerRenderer } from './renderer';
+// Patterns
+export { 
+// Core noise functions
+perlinNoise2D, fbmNoise, staticNoise, seededNoise2D, 
+// Pattern generators
+wavePattern, ripplePattern, cloudsPattern, plasmaPattern, vortexPattern, matrixPattern, gradientPattern, diamondPattern, fractalPattern, 
+// Grid generation (legacy API)
+generateBrightnessGrid, gridToImageData, 
+// Performance-optimized API
+createBrightnessBuffer, fillBrightnessBuffer, getBufferValue, 
+// Config
+DEFAULT_PATTERN_CONFIG, } from './patterns';
+// Characters
+export { CHARACTER_SETS, getCharacterSet, getCharacters, getCharacterSetNames, createCharacterSet, validateCharacterSet, invertCharacters, } from './characters';
+// Colors (Grove palette)
+export { GROVE_GREEN, CREAM, BARK, STATUS, GROVE_COLORS, GLASS_SCHEMES, getGroveColor, getGlassScheme, getGroveColorNames, getGlassSchemeNames, hexToRgba, } from './colors';
+// Animation
+export { createAnimationLoop, throttle, debounce, calculateFPS, easings, } from './animation';
+// Canvas Utilities
+export { createCanvas, getDevicePixelRatio, resizeCanvasToContainer, createOffscreenCanvas, clearCanvas, getImageData, optimizeContext, setupTextRendering, measureTextWidth, calculateCellSize, setBlendMode, } from './utils/canvas';
+// Image Utilities
+export { loadImage, loadAndScaleImage, imageToPixelData, extractBrightness, sampleImageCells, rgbToHex, hexToRgb, adjustBrightness, adjustContrast, invertColors, toGrayscale, } from './utils/image';
+// Performance Utilities
+export { createVisibilityObserver, createResizeObserver, prefersReducedMotion, onReducedMotionChange, isLowPowerMode, getRecommendedFPS, createFPSCounter, requestIdleCallback, cancelIdleCallback, isBrowser, isCanvasSupported, isOffscreenCanvasSupported, } from './utils/performance';
+// =============================================================================
+// Version
+// =============================================================================
+/**
+ * Gossamer version
+ */
+export const VERSION = '0.1.0';