@jyiro/ascii-script 0.1.0

package/dist/ascii-script.js

@@ -0,0 +1,892 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _instances, _running, _rafId, _lastTime, _loop, _instances2, _nextId, _id, _element, _active, _effects, _startTime, _callbacks, _BaseInstance_instances, trigger_fn, _originalText, _currentText, _effectChain, _renderMode, _threshold, _canvas, _ctx, _TextBlock_instances, setup_fn, setupCanvas_fn, updateDOM_fn, renderCanvas_fn, _canvas2, _ctx2, _cols, _rows, _charset, _cellWidth, _cellHeight, _grid, _generator, _CanvasGrid_instances, setup_fn2, _defaultGenerator, valueToChar_fn, _engine, _registry, _autoStart, _block, _asciiFX, _grid2, _asciiFX2;
+class Engine {
+  constructor() {
+    __privateAdd(this, _instances, /* @__PURE__ */ new Map());
+    __privateAdd(this, _running, false);
+    __privateAdd(this, _rafId, null);
+    __privateAdd(this, _lastTime, 0);
+    /**
+     * Main render loop
+     * @private
+     */
+    __privateAdd(this, _loop, () => {
+      if (!__privateGet(this, _running)) return;
+      const time = performance.now();
+      const delta = time - __privateGet(this, _lastTime);
+      __privateSet(this, _lastTime, time);
+      for (const instance of __privateGet(this, _instances).values()) {
+        if (instance.active) {
+          instance.update(time, delta);
+        }
+      }
+      __privateSet(this, _rafId, requestAnimationFrame(__privateGet(this, _loop)));
+    });
+  }
+  /**
+   * Register an instance to be updated each frame
+   * @param {string} id - Unique instance identifier
+   * @param {Object} instance - Instance with update() method
+   */
+  register(id, instance) {
+    __privateGet(this, _instances).set(id, instance);
+  }
+  /**
+   * Unregister an instance
+   * @param {string} id - Instance identifier
+   */
+  unregister(id) {
+    __privateGet(this, _instances).delete(id);
+  }
+  /**
+   * Start the rendering loop
+   */
+  start() {
+    if (__privateGet(this, _running)) return;
+    __privateSet(this, _running, true);
+    __privateSet(this, _lastTime, performance.now());
+    __privateGet(this, _loop).call(this);
+  }
+  /**
+   * Stop the rendering loop
+   */
+  stop() {
+    __privateSet(this, _running, false);
+    if (__privateGet(this, _rafId)) {
+      cancelAnimationFrame(__privateGet(this, _rafId));
+      __privateSet(this, _rafId, null);
+    }
+  }
+  /**
+   * Get instance count
+   */
+  get instanceCount() {
+    return __privateGet(this, _instances).size;
+  }
+  /**
+   * Check if engine is running
+   */
+  get isRunning() {
+    return __privateGet(this, _running);
+  }
+}
+_instances = new WeakMap();
+_running = new WeakMap();
+_rafId = new WeakMap();
+_lastTime = new WeakMap();
+_loop = new WeakMap();
+class Registry {
+  constructor() {
+    __privateAdd(this, _instances2, /* @__PURE__ */ new Map());
+    __privateAdd(this, _nextId, 1);
+  }
+  /**
+   * Create a new instance ID
+   * @param {string} prefix - Instance prefix (e.g., 'text', 'grid')
+   * @returns {string} Unique instance ID
+   */
+  createId(prefix = "instance") {
+    return `${prefix}-${__privateWrapper(this, _nextId)._++}`;
+  }
+  /**
+   * Add instance to registry
+   * @param {string} id - Instance ID
+   * @param {Object} instance - Instance object
+   */
+  add(id, instance) {
+    __privateGet(this, _instances2).set(id, instance);
+  }
+  /**
+   * Get instance by ID
+   * @param {string} id - Instance ID
+   * @returns {Object|undefined} Instance or undefined
+   */
+  get(id) {
+    return __privateGet(this, _instances2).get(id);
+  }
+  /**
+   * Remove instance from registry
+   * @param {string} id - Instance ID
+   * @returns {boolean} True if removed
+   */
+  remove(id) {
+    return __privateGet(this, _instances2).delete(id);
+  }
+  /**
+   * Get all instances
+   * @returns {Map} All instances
+   */
+  getAll() {
+    return new Map(__privateGet(this, _instances2));
+  }
+  /**
+   * Clear all instances
+   */
+  clear() {
+    __privateGet(this, _instances2).clear();
+  }
+  /**
+   * Get instance count
+   */
+  get size() {
+    return __privateGet(this, _instances2).size;
+  }
+}
+_instances2 = new WeakMap();
+_nextId = new WeakMap();
+class BaseInstance {
+  constructor(id, element) {
+    __privateAdd(this, _BaseInstance_instances);
+    __privateAdd(this, _id);
+    __privateAdd(this, _element);
+    __privateAdd(this, _active, false);
+    __privateAdd(this, _effects, []);
+    __privateAdd(this, _startTime, null);
+    __privateAdd(this, _callbacks, {});
+    __privateSet(this, _id, id);
+    __privateSet(this, _element, element);
+  }
+  /**
+   * Update instance each frame
+   * @param {number} time - Current time
+   * @param {number} delta - Time since last frame
+   */
+  update(time, delta) {
+    if (!__privateGet(this, _active)) return;
+    if (!__privateGet(this, _startTime)) __privateSet(this, _startTime, time);
+    this.render(time, delta);
+  }
+  /**
+   * Render method (override in subclasses)
+   * @param {number} time - Current time
+   * @param {number} delta - Time since last frame
+   */
+  render(time, delta) {
+    throw new Error("render() must be implemented");
+  }
+  /**
+   * Play/start instance
+   */
+  play() {
+    __privateSet(this, _active, true);
+    __privateSet(this, _startTime, null);
+    __privateMethod(this, _BaseInstance_instances, trigger_fn).call(this, "start");
+  }
+  /**
+   * Pause instance
+   */
+  pause() {
+    __privateSet(this, _active, false);
+    __privateMethod(this, _BaseInstance_instances, trigger_fn).call(this, "pause");
+  }
+  /**
+   * Stop and reset instance
+   */
+  stop() {
+    __privateSet(this, _active, false);
+    __privateSet(this, _startTime, null);
+    __privateMethod(this, _BaseInstance_instances, trigger_fn).call(this, "stop");
+  }
+  /**
+   * Add event callback
+   * @param {string} event - Event name (start, pause, stop, complete, update)
+   * @param {Function} callback - Callback function
+   */
+  on(event, callback) {
+    if (!__privateGet(this, _callbacks)[event]) {
+      __privateGet(this, _callbacks)[event] = [];
+    }
+    __privateGet(this, _callbacks)[event].push(callback);
+    return this;
+  }
+  // Getters
+  get id() {
+    return __privateGet(this, _id);
+  }
+  get element() {
+    return __privateGet(this, _element);
+  }
+  get active() {
+    return __privateGet(this, _active);
+  }
+  get startTime() {
+    return __privateGet(this, _startTime);
+  }
+  get effects() {
+    return __privateGet(this, _effects);
+  }
+}
+_id = new WeakMap();
+_element = new WeakMap();
+_active = new WeakMap();
+_effects = new WeakMap();
+_startTime = new WeakMap();
+_callbacks = new WeakMap();
+_BaseInstance_instances = new WeakSet();
+/**
+ * Trigger event callbacks
+ * @private
+ */
+trigger_fn = function(event, data) {
+  const callbacks = __privateGet(this, _callbacks)[event] || [];
+  callbacks.forEach((cb) => cb(data));
+};
+class TextBlock extends BaseInstance {
+  constructor(id, element, config = {}) {
+    super(id, element);
+    __privateAdd(this, _TextBlock_instances);
+    __privateAdd(this, _originalText, "");
+    __privateAdd(this, _currentText, "");
+    __privateAdd(this, _effectChain, []);
+    __privateAdd(this, _renderMode, "auto");
+    // 'auto', 'dom', 'canvas'
+    __privateAdd(this, _threshold, 100);
+    // Line threshold for canvas rendering
+    __privateAdd(this, _canvas, null);
+    __privateAdd(this, _ctx, null);
+    __privateSet(this, _originalText, element.textContent || "");
+    __privateSet(this, _renderMode, config.renderMode || "auto");
+    __privateSet(this, _threshold, config.threshold || 100);
+    __privateMethod(this, _TextBlock_instances, setup_fn).call(this);
+  }
+  /**
+   * Use an effect
+   * @param {Function} effect - Effect function or dynamic import
+   * @param {Object} options - Options
+   * @param {boolean} options.replace - Replace existing effects (default: true)
+   */
+  async useEffect(effect, options = {}) {
+    const { replace = true } = options;
+    if (typeof effect === "function" && effect.constructor.name === "AsyncFunction") {
+      effect = await effect();
+    }
+    if (replace) {
+      this.clearEffects();
+    }
+    __privateGet(this, _effectChain).push(effect);
+    return this;
+  }
+  /**
+   * Clear all effects
+   */
+  clearEffects() {
+    for (const effect of __privateGet(this, _effectChain)) {
+      if (typeof effect.destroy === "function") {
+        effect.destroy();
+      }
+    }
+    __privateSet(this, _effectChain, []);
+    if (this.element) {
+      this.element.style.transform = "";
+      this.element.innerHTML = "";
+      this.element.textContent = __privateGet(this, _originalText);
+    }
+    return this;
+  }
+  /**
+   * Reset to original state
+   */
+  reset() {
+    this.stop();
+    this.clearEffects();
+    return this;
+  }
+  /**
+   * Render text with effects
+   * @param {number} time - Current time
+   * @param {number} delta - Delta time
+   */
+  render(time, delta) {
+    let text = __privateGet(this, _originalText);
+    let hasHTML = false;
+    for (const effect of __privateGet(this, _effectChain)) {
+      if (typeof effect.render === "function") {
+        const result = effect.render(text, time - this.startTime, {
+          originalText: __privateGet(this, _originalText),
+          element: this.element
+        });
+        if (result && typeof result === "object" && result.__html) {
+          text = result.__text || text;
+          this.element.innerHTML = result.__html;
+          hasHTML = true;
+        } else {
+          text = result;
+        }
+      }
+    }
+    __privateSet(this, _currentText, text);
+    if (!hasHTML) {
+      __privateMethod(this, _TextBlock_instances, updateDOM_fn).call(this);
+    }
+  }
+  /**
+   * Get current text
+   */
+  get text() {
+    return __privateGet(this, _currentText);
+  }
+  /**
+   * Set new text
+   */
+  set text(value) {
+    __privateSet(this, _originalText, value);
+    __privateSet(this, _currentText, value);
+    __privateMethod(this, _TextBlock_instances, updateDOM_fn).call(this);
+  }
+}
+_originalText = new WeakMap();
+_currentText = new WeakMap();
+_effectChain = new WeakMap();
+_renderMode = new WeakMap();
+_threshold = new WeakMap();
+_canvas = new WeakMap();
+_ctx = new WeakMap();
+_TextBlock_instances = new WeakSet();
+/**
+ * Setup element and detect rendering mode
+ * @private
+ */
+setup_fn = function() {
+  const lineCount = __privateGet(this, _originalText).split("\n").length;
+  const hasMultiline = __privateGet(this, _originalText).includes("\n");
+  if (hasMultiline) {
+    this.element.style.whiteSpace = "pre";
+    this.element.style.fontFamily = "monospace";
+  }
+  if (__privateGet(this, _renderMode) === "auto") {
+    __privateSet(this, _renderMode, lineCount > __privateGet(this, _threshold) ? "canvas" : "dom");
+  }
+  if (__privateGet(this, _renderMode) === "canvas") {
+    __privateMethod(this, _TextBlock_instances, setupCanvas_fn).call(this, lineCount);
+  }
+};
+/**
+ * Setup canvas for large ASCII art
+ * @private
+ */
+setupCanvas_fn = function(lineCount) {
+  __privateSet(this, _canvas, document.createElement("canvas"));
+  __privateSet(this, _ctx, __privateGet(this, _canvas).getContext("2d"));
+  const fontSize = 16;
+  const lineHeight = fontSize * 1.2;
+  const maxLineLength = Math.max(
+    ...__privateGet(this, _originalText).split("\n").map((l) => l.length)
+  );
+  __privateGet(this, _canvas).width = maxLineLength * (fontSize * 0.6);
+  __privateGet(this, _canvas).height = lineCount * lineHeight;
+  __privateGet(this, _canvas).style.fontFamily = "monospace";
+  __privateGet(this, _ctx).font = `${fontSize}px monospace`;
+  __privateGet(this, _ctx).fillStyle = getComputedStyle(this.element).color || "#000";
+  this.element.innerHTML = "";
+  this.element.appendChild(__privateGet(this, _canvas));
+};
+/**
+ * Update DOM or canvas
+ * @private
+ */
+updateDOM_fn = function() {
+  if (__privateGet(this, _renderMode) === "canvas") {
+    __privateMethod(this, _TextBlock_instances, renderCanvas_fn).call(this);
+  } else {
+    this.element.textContent = __privateGet(this, _currentText);
+  }
+};
+/**
+ * Render to canvas
+ * @private
+ */
+renderCanvas_fn = function() {
+  __privateGet(this, _ctx).clearRect(0, 0, __privateGet(this, _canvas).width, __privateGet(this, _canvas).height);
+  const lines = __privateGet(this, _currentText).split("\n");
+  const fontSize = 16;
+  const lineHeight = fontSize * 1.2;
+  lines.forEach((line, i) => {
+    __privateGet(this, _ctx).fillText(line, 0, (i + 1) * lineHeight);
+  });
+};
+class CanvasGrid extends BaseInstance {
+  constructor(id, element, config = {}) {
+    super(id, element);
+    __privateAdd(this, _CanvasGrid_instances);
+    __privateAdd(this, _canvas2, null);
+    __privateAdd(this, _ctx2, null);
+    __privateAdd(this, _cols, 80);
+    __privateAdd(this, _rows, 40);
+    __privateAdd(this, _charset, " .:-=+*#%@");
+    __privateAdd(this, _cellWidth, 10);
+    __privateAdd(this, _cellHeight, 16);
+    __privateAdd(this, _grid, []);
+    __privateAdd(this, _generator, null);
+    /**
+     * Default noise generator
+     * @private
+     */
+    __privateAdd(this, _defaultGenerator, (x, y, time) => {
+      const noise = Math.sin(x * 0.1 + time * 1e-3) * Math.cos(y * 0.1 + time * 1e-3);
+      return (noise + 1) / 2;
+    });
+    __privateSet(this, _cols, config.cols || 80);
+    __privateSet(this, _rows, config.rows || 40);
+    __privateSet(this, _charset, config.charset || " .:-=+*#%@");
+    __privateSet(this, _cellWidth, config.cellWidth || 10);
+    __privateSet(this, _cellHeight, config.cellHeight || 16);
+    __privateSet(this, _generator, config.generator || __privateGet(this, _defaultGenerator));
+    __privateMethod(this, _CanvasGrid_instances, setup_fn2).call(this);
+  }
+  /**
+   * Render grid
+   * @param {number} time - Current time
+   * @param {number} delta - Delta time
+   */
+  render(time, delta) {
+    __privateGet(this, _ctx2).clearRect(0, 0, __privateGet(this, _canvas2).width, __privateGet(this, _canvas2).height);
+    __privateGet(this, _ctx2).fillStyle = getComputedStyle(this.element).color || "#000";
+    for (let y = 0; y < __privateGet(this, _rows); y++) {
+      for (let x = 0; x < __privateGet(this, _cols); x++) {
+        const value = __privateGet(this, _generator).call(this, x, y, time);
+        const char = __privateMethod(this, _CanvasGrid_instances, valueToChar_fn).call(this, value);
+        __privateGet(this, _ctx2).fillText(
+          char,
+          x * __privateGet(this, _cellWidth),
+          y * __privateGet(this, _cellHeight)
+        );
+      }
+    }
+  }
+  /**
+   * Set custom generator function
+   * @param {Function} fn - Generator function (x, y, time) => 0-1
+   */
+  setGenerator(fn) {
+    __privateSet(this, _generator, fn);
+    return this;
+  }
+  /**
+   * Set charset
+   * @param {string} chars - Character set
+   */
+  setCharset(chars) {
+    __privateSet(this, _charset, chars);
+    return this;
+  }
+}
+_canvas2 = new WeakMap();
+_ctx2 = new WeakMap();
+_cols = new WeakMap();
+_rows = new WeakMap();
+_charset = new WeakMap();
+_cellWidth = new WeakMap();
+_cellHeight = new WeakMap();
+_grid = new WeakMap();
+_generator = new WeakMap();
+_CanvasGrid_instances = new WeakSet();
+/**
+ * Setup canvas
+ * @private
+ */
+setup_fn2 = function() {
+  __privateSet(this, _canvas2, document.createElement("canvas"));
+  __privateSet(this, _ctx2, __privateGet(this, _canvas2).getContext("2d"));
+  __privateGet(this, _canvas2).width = __privateGet(this, _cols) * __privateGet(this, _cellWidth);
+  __privateGet(this, _canvas2).height = __privateGet(this, _rows) * __privateGet(this, _cellHeight);
+  __privateGet(this, _canvas2).style.width = "100%";
+  __privateGet(this, _canvas2).style.height = "100%";
+  __privateGet(this, _ctx2).font = `${__privateGet(this, _cellHeight)}px monospace`;
+  __privateGet(this, _ctx2).textBaseline = "top";
+  this.element.innerHTML = "";
+  this.element.appendChild(__privateGet(this, _canvas2));
+  __privateSet(this, _grid, Array(__privateGet(this, _rows)).fill(null).map(
+    () => Array(__privateGet(this, _cols)).fill(0)
+  ));
+};
+_defaultGenerator = new WeakMap();
+/**
+ * Map value to character
+ * @private
+ */
+valueToChar_fn = function(value) {
+  const clampedValue = Math.max(0, Math.min(1, value));
+  const chars = Array.from(__privateGet(this, _charset));
+  const index2 = Math.floor(clampedValue * (chars.length - 1));
+  return chars[index2] || " ";
+};
+async function hologram(config = {}) {
+  const { GlitchEffect } = await import("./text-CKJIlRsq.js").then((n) => n.g);
+  const { PulseEffect } = await import("./ascii-art-DCOQt4Se.js").then((n) => n.p);
+  return [
+    new GlitchEffect({
+      intensity: config.glitchIntensity || 0.08,
+      ...config.glitch
+    }),
+    new PulseEffect({
+      minScale: 0.98,
+      maxScale: 1.02,
+      speed: 3e-3,
+      ...config.pulse
+    })
+  ];
+}
+async function matrix(config = {}) {
+  const { MatrixRainEffect } = await import("./text-CKJIlRsq.js").then((n) => n.m);
+  const { ScanlinesEffect } = await import("./procedural-BY9bCgT3.js");
+  return [
+    new MatrixRainEffect({
+      speed: 0.1,
+      density: 0.05,
+      ...config.matrix
+    }),
+    new ScanlinesEffect({
+      opacity: 0.15,
+      ...config.scanlines
+    })
+  ];
+}
+async function decrypt(config = {}) {
+  const { ScrambleEffect } = await import("./text-CKJIlRsq.js").then((n) => n.s);
+  const { RevealEffect } = await import("./text-CKJIlRsq.js").then((n) => n.r);
+  const duration = config.duration || 2e3;
+  const scrambleDuration = duration * 0.4;
+  const revealDuration = duration * 0.6;
+  return [
+    new ScrambleEffect({
+      duration: scrambleDuration,
+      revealMode: "progressive",
+      ...config.scramble
+    }),
+    new RevealEffect({
+      duration: revealDuration,
+      ...config.reveal
+    })
+  ];
+}
+async function rainbow(config = {}) {
+  const { WaveEffect } = await import("./ascii-art-DCOQt4Se.js").then((n) => n.w);
+  const { ColorCycleEffect } = await import("./ascii-art-DCOQt4Se.js").then((n) => n.c);
+  return [
+    new WaveEffect({
+      amplitude: 3,
+      frequency: 0.8,
+      speed: 2e-3,
+      ...config.wave
+    }),
+    new ColorCycleEffect({
+      speed: 2e-3,
+      spread: 5,
+      saturation: 80,
+      lightness: 60,
+      ...config.color
+    })
+  ];
+}
+async function terminal(config = {}) {
+  const { TypewriterEffect } = await import("./text-CKJIlRsq.js").then((n) => n.t);
+  const { ScanlinesEffect } = await import("./procedural-BY9bCgT3.js");
+  return [
+    new TypewriterEffect({
+      speed: 50,
+      showCursor: true,
+      ...config.typewriter
+    }),
+    new ScanlinesEffect({
+      opacity: 0.1,
+      lineHeight: 2,
+      ...config.scanlines
+    })
+  ];
+}
+const presets = {
+  hologram,
+  matrix,
+  decrypt,
+  rainbow,
+  terminal
+};
+class AsciiFX {
+  constructor(config = {}) {
+    __privateAdd(this, _engine, null);
+    __privateAdd(this, _registry, null);
+    __privateAdd(this, _autoStart, true);
+    __privateSet(this, _engine, new Engine());
+    __privateSet(this, _registry, new Registry());
+    __privateSet(this, _autoStart, config.autoStart !== false);
+    if (__privateGet(this, _autoStart)) {
+      __privateGet(this, _engine).start();
+    }
+  }
+  /**
+   * Create ASCII art text block
+   * @param {string|HTMLElement} selector - Element or selector
+   * @param {Object} config - Configuration
+   * @returns {TextBlockAPI} Text block API
+   */
+  createArt(selector, config = {}) {
+    const element = typeof selector === "string" ? document.querySelector(selector) : selector;
+    if (!element) {
+      throw new Error(`Element not found: ${selector}`);
+    }
+    const id = __privateGet(this, _registry).createId("text");
+    const block = new TextBlock(id, element, config);
+    __privateGet(this, _registry).add(id, block);
+    __privateGet(this, _engine).register(id, block);
+    return new TextBlockAPI(block, this);
+  }
+  /**
+   * Create text block (alias for createArt)
+   */
+  createText(selector, config = {}) {
+    return this.createArt(selector, config);
+  }
+  /**
+   * Create procedural canvas background
+   * @param {string|HTMLElement} selector - Element or selector
+   * @param {Object} config - Configuration
+   * @returns {CanvasGridAPI} Canvas grid API
+   */
+  createBackground(selector, config = {}) {
+    const element = typeof selector === "string" ? document.querySelector(selector) : selector;
+    if (!element) {
+      throw new Error(`Element not found: ${selector}`);
+    }
+    const id = __privateGet(this, _registry).createId("grid");
+    const grid = new CanvasGrid(id, element, config);
+    __privateGet(this, _registry).add(id, grid);
+    __privateGet(this, _engine).register(id, grid);
+    return new CanvasGridAPI(grid, this);
+  }
+  /**
+   * Start engine
+   */
+  start() {
+    __privateGet(this, _engine).start();
+    return this;
+  }
+  /**
+   * Stop engine
+   */
+  stop() {
+    __privateGet(this, _engine).stop();
+    return this;
+  }
+  /**
+   * Get instance by ID
+   */
+  getInstance(id) {
+    return __privateGet(this, _registry).get(id);
+  }
+  /**
+   * Destroy instance
+   */
+  destroy(id) {
+    __privateGet(this, _engine).unregister(id);
+    __privateGet(this, _registry).remove(id);
+    return this;
+  }
+  /**
+   * Get presets
+   */
+  get presets() {
+    return presets;
+  }
+}
+_engine = new WeakMap();
+_registry = new WeakMap();
+_autoStart = new WeakMap();
+class TextBlockAPI {
+  constructor(block, asciiFX) {
+    __privateAdd(this, _block);
+    __privateAdd(this, _asciiFX);
+    __privateSet(this, _block, block);
+    __privateSet(this, _asciiFX, asciiFX);
+  }
+  /**
+   * Apply effect
+   * @param {Object} effect - Effect instance
+   * @param {Object} options - Options
+   * @param {boolean} options.replace - Replace existing effects (default: true)
+   */
+  async useEffect(effect, options) {
+    await __privateGet(this, _block).useEffect(effect, options);
+    return this;
+  }
+  /**
+   * Apply preset
+   */
+  async preset(name, config = {}) {
+    const presetFn = presets[name];
+    if (!presetFn) {
+      throw new Error(`Preset not found: ${name}`);
+    }
+    const effects = await presetFn(config);
+    for (let i = 0; i < effects.length; i++) {
+      await __privateGet(this, _block).useEffect(effects[i], { replace: i === 0 });
+    }
+    return this;
+  }
+  /**
+   * Fluent API for effects
+   */
+  async wave(config) {
+    const { WaveEffect } = await import("./ascii-art-DCOQt4Se.js").then((n) => n.w);
+    return this.useEffect(new WaveEffect(config), { replace: false });
+  }
+  async colorCycle(config) {
+    const { ColorCycleEffect } = await import("./ascii-art-DCOQt4Se.js").then((n) => n.c);
+    return this.useEffect(new ColorCycleEffect(config), { replace: false });
+  }
+  async colorGradient(config) {
+    const { ColorGradientEffect } = await import("./ascii-art-DCOQt4Se.js").then((n) => n.a);
+    return this.useEffect(new ColorGradientEffect(config), { replace: false });
+  }
+  async pulse(config) {
+    const { PulseEffect } = await import("./ascii-art-DCOQt4Se.js").then((n) => n.p);
+    return this.useEffect(new PulseEffect(config), { replace: false });
+  }
+  async perspective(config) {
+    const { PerspectiveEffect } = await import("./ascii-art-DCOQt4Se.js").then((n) => n.b);
+    return this.useEffect(new PerspectiveEffect(config), { replace: false });
+  }
+  async scramble(config) {
+    const { ScrambleEffect } = await import("./text-CKJIlRsq.js").then((n) => n.s);
+    return this.useEffect(new ScrambleEffect(config), { replace: false });
+  }
+  async reveal(config) {
+    const { RevealEffect } = await import("./text-CKJIlRsq.js").then((n) => n.r);
+    return this.useEffect(new RevealEffect(config), { replace: false });
+  }
+  async glitch(config) {
+    const { GlitchEffect } = await import("./text-CKJIlRsq.js").then((n) => n.g);
+    return this.useEffect(new GlitchEffect(config), { replace: false });
+  }
+  async typewriter(config) {
+    const { TypewriterEffect } = await import("./text-CKJIlRsq.js").then((n) => n.t);
+    return this.useEffect(new TypewriterEffect(config), { replace: false });
+  }
+  async matrix(config) {
+    const { MatrixRainEffect } = await import("./text-CKJIlRsq.js").then((n) => n.m);
+    return this.useEffect(new MatrixRainEffect(config), { replace: false });
+  }
+  /**
+   * Clear all effects
+   */
+  clearEffects() {
+    __privateGet(this, _block).clearEffects();
+    return this;
+  }
+  /**
+   * Reset to original state
+   */
+  reset() {
+    __privateGet(this, _block).reset();
+    return this;
+  }
+  /**
+   * Control methods
+   */
+  play() {
+    __privateGet(this, _block).play();
+    return this;
+  }
+  pause() {
+    __privateGet(this, _block).pause();
+    return this;
+  }
+  stop() {
+    __privateGet(this, _block).stop();
+    return this;
+  }
+  destroy() {
+    __privateGet(this, _block).stop();
+    __privateGet(this, _asciiFX).destroy(__privateGet(this, _block).id);
+    return this;
+  }
+  /**
+   * Event handlers
+   */
+  on(event, callback) {
+    __privateGet(this, _block).on(event, callback);
+    return this;
+  }
+  /**
+   * Get instance
+   */
+  get instance() {
+    return __privateGet(this, _block);
+  }
+  /**
+   * Get instance ID
+   */
+  get id() {
+    return __privateGet(this, _block).id;
+  }
+}
+_block = new WeakMap();
+_asciiFX = new WeakMap();
+class CanvasGridAPI {
+  constructor(grid, asciiFX) {
+    __privateAdd(this, _grid2);
+    __privateAdd(this, _asciiFX2);
+    __privateSet(this, _grid2, grid);
+    __privateSet(this, _asciiFX2, asciiFX);
+  }
+  setGenerator(fn) {
+    __privateGet(this, _grid2).setGenerator(fn);
+    return this;
+  }
+  setCharset(chars) {
+    __privateGet(this, _grid2).setCharset(chars);
+    return this;
+  }
+  play() {
+    __privateGet(this, _grid2).play();
+    return this;
+  }
+  pause() {
+    __privateGet(this, _grid2).pause();
+    return this;
+  }
+  stop() {
+    __privateGet(this, _grid2).stop();
+    return this;
+  }
+  destroy() {
+    __privateGet(this, _grid2).stop();
+    __privateGet(this, _asciiFX2).destroy(__privateGet(this, _grid2).id);
+    return this;
+  }
+  on(event, callback) {
+    __privateGet(this, _grid2).on(event, callback);
+    return this;
+  }
+  get instance() {
+    return __privateGet(this, _grid2);
+  }
+  get id() {
+    return __privateGet(this, _grid2).id;
+  }
+}
+_grid2 = new WeakMap();
+_asciiFX2 = new WeakMap();
+function create(config) {
+  return new AsciiFX(config);
+}
+const index = { create, AsciiFX };
+export {
+  AsciiFX,
+  create,
+  index as default
+};