@autumnsgrove/gossamer 0.0.1 → 0.1.0

package/dist/index.js

@@ -1,3 +1,1229 @@
+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;
+    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();
+  }
+  /**
+   * 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) {
+    this.config = { ...this.config, ...config };
+    this.setupCanvas();
+  }
+  /**
+   * 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);
+      }
+    }
+  }
+  /**
+   * 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 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":
+        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);
+}
+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"]
+  }
+};
+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("");
+}
+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,
@@ -16,12 +1242,68 @@ 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.0.1";
+const VERSION = "0.1.0";
 export {
+  CHARACTER_SETS,
   DEFAULT_CHARACTERS,
   DEFAULT_CONFIG,
+  DEFAULT_PATTERN_CONFIG,
+  GossamerRenderer,
   VERSION,
+  adjustBrightness,
+  adjustContrast,
   brightnessToChar,
-  calculateBrightness
+  calculateBrightness,
+  calculateCellSize,
+  calculateFPS,
+  cancelIdleCallback,
+  clearCanvas,
+  createAnimationLoop,
+  createCanvas,
+  createCharacterSet,
+  createFPSCounter,
+  createOffscreenCanvas,
+  createResizeObserver,
+  createVisibilityObserver,
+  debounce,
+  easings,
+  extractBrightness,
+  fbmNoise,
+  generateBrightnessGrid,
+  getCharacterSet,
+  getCharacterSetNames,
+  getCharacters,
+  getDevicePixelRatio,
+  getImageData,
+  getRecommendedFPS,
+  gridToImageData,
+  hexToRgb,
+  imageToPixelData,
+  invertCharacters,
+  invertColors,
+  isBrowser,
+  isCanvasSupported,
+  isLowPowerMode,
+  isOffscreenCanvasSupported,
+  loadAndScaleImage,
+  loadImage,
+  measureTextWidth,
+  onReducedMotionChange,
+  optimizeContext,
+  perlinNoise2D,
+  prefersReducedMotion,
+  requestIdleCallback,
+  resizeCanvasToContainer,
+  rgbToHex,
+  ripplePattern,
+  sampleImageCells,
+  seededNoise2D,
+  setBlendMode,
+  setupTextRendering,
+  staticNoise,
+  throttle,
+  toGrayscale,
+  validateCharacterSet,
+  wavePattern
 };
 //# sourceMappingURL=index.js.map