@opentui/core 0.1.89 → 0.1.90

package/{index-rs5zwr4j.js → index-k03avn41.js}

@@ -295,6 +295,7 @@ __export(exports_src2, {
   applyAsciiArt: () => applyAsciiArt,
   addDefaultParsers: () => addDefaultParsers,
   Yoga: () => exports_src,
+  VignetteEffect: () => VignetteEffect,
   VRenderable: () => VRenderable,
   TreeSitterClient: () => TreeSitterClient,
   Timeline: () => Timeline,
@@ -314,6 +315,9 @@ __export(exports_src2, {
   TabSelectRenderableEvents: () => TabSelectRenderableEvents,
   TabSelectRenderable: () => TabSelectRenderable,
   TabSelect: () => TabSelect,
+  TRITANOPIA_SIM_MATRIX: () => TRITANOPIA_SIM_MATRIX,
+  TRITANOPIA_COMP_MATRIX: () => TRITANOPIA_COMP_MATRIX,
+  TECHNICOLOR_MATRIX: () => TECHNICOLOR_MATRIX,
   SystemClock: () => SystemClock,
   SyntaxStyle: () => SyntaxStyle,
   StyledText: () => StyledText,
@@ -328,13 +332,19 @@ __export(exports_src2, {
   ScrollBoxRenderable: () => ScrollBoxRenderable,
   ScrollBox: () => ScrollBox,
   ScrollBarRenderable: () => ScrollBarRenderable,
+  SYNTHWAVE_MATRIX: () => SYNTHWAVE_MATRIX,
+  SOLARIZATION_MATRIX: () => SOLARIZATION_MATRIX,
+  SEPIA_MATRIX: () => SEPIA_MATRIX,
   RootTextNodeRenderable: () => RootTextNodeRenderable,
   RootRenderable: () => RootRenderable,
   RendererControlState: () => RendererControlState,
   RenderableEvents: () => RenderableEvents,
   Renderable: () => Renderable,
+  RainbowTextEffect: () => RainbowTextEffect,
   RGBA: () => RGBA,
   PasteEvent: () => PasteEvent,
+  PROTANOPIA_SIM_MATRIX: () => PROTANOPIA_SIM_MATRIX,
+  PROTANOPIA_COMP_MATRIX: () => PROTANOPIA_COMP_MATRIX,
   OptimizedBuffer: () => OptimizedBuffer,
   NativeSpanFeed: () => NativeSpanFeed,
   MouseParser: () => MouseParser,
@@ -352,20 +362,29 @@ __export(exports_src2, {
   InputRenderableEvents: () => InputRenderableEvents,
   InputRenderable: () => InputRenderable,
   Input: () => Input,
+  INVERT_MATRIX: () => INVERT_MATRIX,
   Generic: () => Generic,
+  GREENSCALE_MATRIX: () => GREENSCALE_MATRIX,
+  GRAYSCALE_MATRIX: () => GRAYSCALE_MATRIX,
   FrameBufferRenderable: () => FrameBufferRenderable,
   FrameBuffer: () => FrameBuffer,
+  FlamesEffect: () => FlamesEffect,
   ExtmarksController: () => ExtmarksController,
   EditorView: () => EditorView,
   EditBuffer: () => EditBuffer,
+  DistortionEffect: () => DistortionEffect,
   DiffRenderable: () => DiffRenderable,
   DebugOverlayCorner: () => DebugOverlayCorner,
   DataPathsManager: () => DataPathsManager,
+  DEUTERANOPIA_SIM_MATRIX: () => DEUTERANOPIA_SIM_MATRIX,
+  DEUTERANOPIA_COMP_MATRIX: () => DEUTERANOPIA_COMP_MATRIX,
   ConsolePosition: () => ConsolePosition,
   CodeRenderable: () => CodeRenderable,
   Code: () => Code,
+  CloudsEffect: () => CloudsEffect,
   CliRenderer: () => CliRenderer,
   CliRenderEvents: () => CliRenderEvents,
+  CRTRollingBarEffect: () => CRTRollingBarEffect,
   BoxRenderable: () => BoxRenderable,
   Box: () => Box,
   BorderChars: () => BorderChars,
@@ -377,7 +396,8 @@ __export(exports_src2, {
   ATTRIBUTE_BASE_BITS: () => ATTRIBUTE_BASE_BITS,
   ASCIIFontSelectionHelper: () => ASCIIFontSelectionHelper,
   ASCIIFontRenderable: () => ASCIIFontRenderable,
-  ASCIIFont: () => ASCIIFont
+  ASCIIFont: () => ASCIIFont,
+  ACHROMATOPSIA_MATRIX: () => ACHROMATOPSIA_MATRIX
 });
 
 // src/text-buffer-view.ts
@@ -1202,6 +1222,636 @@ class SyntaxStyle {
     this.lib.destroySyntaxStyle(this.stylePtr);
   }
 }
+// src/post/effects.ts
+class DistortionEffect {
+  glitchChancePerSecond = 0.5;
+  maxGlitchLines = 3;
+  minGlitchDuration = 0.05;
+  maxGlitchDuration = 0.2;
+  maxShiftAmount = 10;
+  shiftFlipRatio = 0.6;
+  colorGlitchChance = 0.2;
+  lastGlitchTime = 0;
+  glitchDuration = 0;
+  activeGlitches = [];
+  constructor(options) {
+    if (options) {
+      Object.assign(this, options);
+    }
+  }
+  apply(buffer, deltaTime) {
+    const width = buffer.width;
+    const height = buffer.height;
+    const buf = buffer.buffers;
+    this.lastGlitchTime += deltaTime;
+    if (this.activeGlitches.length > 0 && this.lastGlitchTime >= this.glitchDuration) {
+      this.activeGlitches = [];
+      this.glitchDuration = 0;
+    }
+    if (this.activeGlitches.length === 0 && Math.random() < this.glitchChancePerSecond * deltaTime) {
+      this.lastGlitchTime = 0;
+      this.glitchDuration = this.minGlitchDuration + Math.random() * (this.maxGlitchDuration - this.minGlitchDuration);
+      const numGlitches = 1 + Math.floor(Math.random() * this.maxGlitchLines);
+      for (let i = 0;i < numGlitches; i++) {
+        const y = Math.floor(Math.random() * height);
+        let type;
+        let amount = 0;
+        const typeRoll = Math.random();
+        if (typeRoll < this.colorGlitchChance) {
+          type = "color";
+        } else {
+          const shiftRoll = (typeRoll - this.colorGlitchChance) / (1 - this.colorGlitchChance);
+          if (shiftRoll < this.shiftFlipRatio) {
+            type = "shift";
+            amount = Math.floor((Math.random() - 0.5) * 2 * this.maxShiftAmount);
+          } else {
+            type = "flip";
+          }
+        }
+        if (!this.activeGlitches.some((g) => g.y === y)) {
+          this.activeGlitches.push({ y, type, amount });
+        }
+      }
+    }
+    if (this.activeGlitches.length > 0) {
+      let tempChar = null;
+      let tempFg = null;
+      let tempBg = null;
+      let tempAttr = null;
+      for (const glitch of this.activeGlitches) {
+        const y = glitch.y;
+        if (y < 0 || y >= height)
+          continue;
+        const baseIndex = y * width;
+        if (glitch.type === "shift" || glitch.type === "flip") {
+          if (!tempChar) {
+            tempChar = new Uint32Array(width);
+            tempFg = new Float32Array(width * 4);
+            tempBg = new Float32Array(width * 4);
+            tempAttr = new Uint8Array(width);
+          }
+          try {
+            tempChar.set(buf.char.subarray(baseIndex, baseIndex + width));
+            tempFg.set(buf.fg.subarray(baseIndex * 4, (baseIndex + width) * 4));
+            tempBg.set(buf.bg.subarray(baseIndex * 4, (baseIndex + width) * 4));
+            tempAttr.set(buf.attributes.subarray(baseIndex, baseIndex + width));
+          } catch (e) {
+            console.error(`Error copying row ${y} for distortion:`, e);
+            continue;
+          }
+          if (glitch.type === "shift") {
+            const shift = glitch.amount;
+            for (let x = 0;x < width; x++) {
+              const srcX = (x - shift + width) % width;
+              const destIndex = baseIndex + x;
+              const srcTempIndex = srcX;
+              buf.char[destIndex] = tempChar[srcTempIndex];
+              buf.attributes[destIndex] = tempAttr[srcTempIndex];
+              const destColorIndex = destIndex * 4;
+              const srcTempColorIndex = srcTempIndex * 4;
+              buf.fg.set(tempFg.subarray(srcTempColorIndex, srcTempColorIndex + 4), destColorIndex);
+              buf.bg.set(tempBg.subarray(srcTempColorIndex, srcTempColorIndex + 4), destColorIndex);
+            }
+          } else {
+            for (let x = 0;x < width; x++) {
+              const srcX = width - 1 - x;
+              const destIndex = baseIndex + x;
+              const srcTempIndex = srcX;
+              buf.char[destIndex] = tempChar[srcTempIndex];
+              buf.attributes[destIndex] = tempAttr[srcTempIndex];
+              const destColorIndex = destIndex * 4;
+              const srcTempColorIndex = srcTempIndex * 4;
+              buf.fg.set(tempFg.subarray(srcTempColorIndex, srcTempColorIndex + 4), destColorIndex);
+              buf.bg.set(tempBg.subarray(srcTempColorIndex, srcTempColorIndex + 4), destColorIndex);
+            }
+          }
+        } else if (glitch.type === "color") {
+          const glitchStart = Math.floor(Math.random() * width);
+          const maxPossibleLength = width - glitchStart;
+          let glitchLength = Math.floor(Math.random() * maxPossibleLength) + 1;
+          if (Math.random() < 0.2) {
+            glitchLength = Math.floor(Math.random() * (width / 4)) + 1;
+          }
+          glitchLength = Math.min(glitchLength, maxPossibleLength);
+          for (let x = glitchStart;x < glitchStart + glitchLength; x++) {
+            if (x >= width)
+              break;
+            const destIndex = baseIndex + x;
+            const destColorIndex = destIndex * 4;
+            let rFg, gFg, bFg, rBg, gBg, bBg;
+            const colorMode = Math.random();
+            if (colorMode < 0.33) {
+              rFg = Math.random();
+              gFg = Math.random();
+              bFg = Math.random();
+              rBg = Math.random();
+              gBg = Math.random();
+              bBg = Math.random();
+            } else if (colorMode < 0.66) {
+              const emphasis = Math.random();
+              if (emphasis < 0.25) {
+                rFg = Math.random();
+                gFg = 0;
+                bFg = 0;
+              } else if (emphasis < 0.5) {
+                rFg = 0;
+                gFg = Math.random();
+                bFg = 0;
+              } else if (emphasis < 0.75) {
+                rFg = 0;
+                gFg = 0;
+                bFg = Math.random();
+              } else {
+                const glitchColorRoll = Math.random();
+                if (glitchColorRoll < 0.33) {
+                  rFg = 1;
+                  gFg = 0;
+                  bFg = 1;
+                } else if (glitchColorRoll < 0.66) {
+                  rFg = 0;
+                  gFg = 1;
+                  bFg = 1;
+                } else {
+                  rFg = 1;
+                  gFg = 1;
+                  bFg = 0;
+                }
+              }
+              if (Math.random() < 0.5) {
+                rBg = 1 - rFg;
+                gBg = 1 - gFg;
+                bBg = 1 - bFg;
+              } else {
+                rBg = rFg * (Math.random() * 0.5 + 0.2);
+                gBg = gFg * (Math.random() * 0.5 + 0.2);
+                bBg = bFg * (Math.random() * 0.5 + 0.2);
+              }
+            } else {
+              rFg = Math.random() > 0.5 ? 1 : 0;
+              gFg = Math.random() > 0.5 ? 1 : 0;
+              bFg = Math.random() > 0.5 ? 1 : 0;
+              rBg = 1 - rFg;
+              gBg = 1 - gFg;
+              bBg = 1 - bFg;
+            }
+            buf.fg[destColorIndex] = rFg;
+            buf.fg[destColorIndex + 1] = gFg;
+            buf.fg[destColorIndex + 2] = bFg;
+            buf.bg[destColorIndex] = rBg;
+            buf.bg[destColorIndex + 1] = gBg;
+            buf.bg[destColorIndex + 2] = bBg;
+          }
+        }
+      }
+    }
+  }
+}
+
+class VignetteEffect {
+  _strength;
+  precomputedAttenuationCellMask = null;
+  cachedWidth = -1;
+  cachedHeight = -1;
+  static zeroMatrix = new Float32Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+  constructor(strength = 0.5) {
+    this._strength = strength;
+  }
+  set strength(newStrength) {
+    this._strength = Math.max(0, newStrength);
+    this.cachedWidth = -1;
+    this.cachedHeight = -1;
+    this.precomputedAttenuationCellMask = null;
+  }
+  get strength() {
+    return this._strength;
+  }
+  _computeFactors(width, height) {
+    this.precomputedAttenuationCellMask = new Float32Array(width * height * 3);
+    const centerX = width / 2;
+    const centerY = height / 2;
+    const maxDistSq = centerX * centerX + centerY * centerY;
+    const safeMaxDistSq = maxDistSq === 0 ? 1 : maxDistSq;
+    const strength = this._strength;
+    let i = 0;
+    for (let y = 0;y < height; y++) {
+      const dy = y - centerY;
+      const dySq = dy * dy;
+      for (let x = 0;x < width; x++) {
+        const dx = x - centerX;
+        const distSq = dx * dx + dySq;
+        const baseAttenuation = Math.min(1, distSq / safeMaxDistSq);
+        const attenuation = baseAttenuation * strength;
+        this.precomputedAttenuationCellMask[i++] = x;
+        this.precomputedAttenuationCellMask[i++] = y;
+        this.precomputedAttenuationCellMask[i++] = attenuation;
+      }
+    }
+    this.cachedWidth = width;
+    this.cachedHeight = height;
+  }
+  apply(buffer) {
+    const width = buffer.width;
+    const height = buffer.height;
+    if (width !== this.cachedWidth || height !== this.cachedHeight || !this.precomputedAttenuationCellMask) {
+      this._computeFactors(width, height);
+    }
+    buffer.colorMatrix(VignetteEffect.zeroMatrix, this.precomputedAttenuationCellMask, 1, 3);
+  }
+}
+
+class PerlinNoise {
+  perm;
+  grad3 = [
+    [1, 1, 0],
+    [-1, 1, 0],
+    [1, -1, 0],
+    [-1, -1, 0],
+    [1, 0, 1],
+    [-1, 0, 1],
+    [1, 0, -1],
+    [-1, 0, -1],
+    [0, 1, 1],
+    [0, -1, 1],
+    [0, 1, -1],
+    [0, -1, -1]
+  ];
+  constructor() {
+    this.perm = new Uint8Array(512);
+    const p = new Uint8Array(256);
+    for (let i = 0;i < 256; i++) {
+      p[i] = i;
+    }
+    for (let i = 255;i > 0; i--) {
+      const r = Math.floor(Math.random() * (i + 1));
+      [p[i], p[r]] = [p[r], p[i]];
+    }
+    for (let i = 0;i < 512; i++) {
+      this.perm[i] = p[i & 255];
+    }
+  }
+  dot(g, x, y, z) {
+    return g[0] * x + g[1] * y + g[2] * z;
+  }
+  mix(a, b, t2) {
+    return a + (b - a) * t2;
+  }
+  fade(t2) {
+    return t2 * t2 * t2 * (t2 * (t2 * 6 - 15) + 10);
+  }
+  noise3d(x, y, z) {
+    const X = Math.floor(x) & 255;
+    const Y = Math.floor(y) & 255;
+    const Z = Math.floor(z) & 255;
+    const xf = x - Math.floor(x);
+    const yf = y - Math.floor(y);
+    const zf = z - Math.floor(z);
+    const u = this.fade(xf);
+    const v = this.fade(yf);
+    const w = this.fade(zf);
+    const A = this.perm[X] + Y;
+    const AA = this.perm[A] + Z;
+    const AB = this.perm[A + 1] + Z;
+    const B = this.perm[X + 1] + Y;
+    const BA = this.perm[B] + Z;
+    const BB = this.perm[B + 1] + Z;
+    let res = this.mix(this.mix(this.mix(this.dot(this.grad3[this.perm[AA] % 12], xf, yf, zf), this.dot(this.grad3[this.perm[BA] % 12], xf - 1, yf, zf), u), this.mix(this.dot(this.grad3[this.perm[AB] % 12], xf, yf - 1, zf), this.dot(this.grad3[this.perm[BB] % 12], xf - 1, yf - 1, zf), u), v), this.mix(this.mix(this.dot(this.grad3[this.perm[AA + 1] % 12], xf, yf, zf - 1), this.dot(this.grad3[this.perm[BA + 1] % 12], xf - 1, yf, zf - 1), u), this.mix(this.dot(this.grad3[this.perm[AB + 1] % 12], xf, yf - 1, zf - 1), this.dot(this.grad3[this.perm[BB + 1] % 12], xf - 1, yf - 1, zf - 1), u), v), w);
+    return res;
+  }
+}
+
+class CloudsEffect {
+  noise;
+  _scale;
+  _speed;
+  _density;
+  _darkness;
+  time = 0;
+  constructor(scale = 0.02, speed = 0.5, density = 0.6, darkness = 0.7) {
+    this.noise = new PerlinNoise;
+    this._scale = scale;
+    this._speed = speed;
+    this._density = density;
+    this._darkness = darkness;
+  }
+  set scale(newScale) {
+    this._scale = Math.max(0.001, newScale);
+  }
+  get scale() {
+    return this._scale;
+  }
+  set speed(newSpeed) {
+    this._speed = Math.max(0, newSpeed);
+  }
+  get speed() {
+    return this._speed;
+  }
+  set density(newDensity) {
+    this._density = Math.max(0, Math.min(1, newDensity));
+  }
+  get density() {
+    return this._density;
+  }
+  set darkness(newDarkness) {
+    this._darkness = Math.max(0, Math.min(1, newDarkness));
+  }
+  get darkness() {
+    return this._darkness;
+  }
+  apply(buffer, deltaTime) {
+    const width = buffer.width;
+    const height = buffer.height;
+    this.time += deltaTime * this._speed;
+    const scale = this._scale;
+    const timeOffset = this.time;
+    const cellMask = new Float32Array(width * height * 3);
+    let maskIdx = 0;
+    for (let y = 0;y < height; y++) {
+      for (let x = 0;x < width; x++) {
+        let noiseValue = 0;
+        let amplitude = 1;
+        let frequency = 1;
+        let maxValue = 0;
+        for (let i = 0;i < 4; i++) {
+          const nx = (x * scale * frequency + timeOffset) * 0.5;
+          const ny = y * scale * frequency * 0.5;
+          const nz = timeOffset * 0.3;
+          noiseValue += this.noise.noise3d(nx, ny, nz) * amplitude;
+          maxValue += amplitude;
+          amplitude *= 0.5;
+          frequency *= 2;
+        }
+        noiseValue = (noiseValue / maxValue + 1) * 0.5;
+        const cloudDensity = Math.max(0, noiseValue - (1 - this._density));
+        const attenuation = cloudDensity * this._darkness;
+        cellMask[maskIdx++] = x;
+        cellMask[maskIdx++] = y;
+        cellMask[maskIdx++] = attenuation;
+      }
+    }
+    const zeroMatrix = new Float32Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    buffer.colorMatrix(zeroMatrix, cellMask, 1, 2);
+  }
+}
+
+class FlamesEffect {
+  noise;
+  _scale;
+  _speed;
+  _intensity;
+  time = 0;
+  constructor(scale = 0.03, speed = 0.02, intensity = 0.8) {
+    this.noise = new PerlinNoise;
+    this._scale = scale;
+    this._speed = speed;
+    this._intensity = intensity;
+  }
+  set scale(newScale) {
+    this._scale = Math.max(0.001, newScale);
+  }
+  get scale() {
+    return this._scale;
+  }
+  set speed(newSpeed) {
+    this._speed = Math.max(0, newSpeed);
+  }
+  get speed() {
+    return this._speed;
+  }
+  set intensity(newIntensity) {
+    this._intensity = Math.max(0, Math.min(1, newIntensity));
+  }
+  get intensity() {
+    return this._intensity;
+  }
+  apply(buffer, deltaTime) {
+    const width = buffer.width;
+    const height = buffer.height;
+    const bg2 = buffer.buffers.bg;
+    this.time += deltaTime * this._speed;
+    const scale = this._scale;
+    const timeOffset = this.time;
+    for (let y = 0;y < height; y++) {
+      const heightFactor = 1 - y / height;
+      for (let x = 0;x < width; x++) {
+        let noiseValue = 0;
+        let amplitude = 1;
+        let frequency = 1;
+        let maxValue = 0;
+        for (let i = 0;i < 3; i++) {
+          const nx = (x * scale * frequency + timeOffset) * 0.5;
+          const ny = (height - y) * scale * frequency * 2 * 0.5;
+          const nz = timeOffset * 2;
+          noiseValue += this.noise.noise3d(nx, ny, nz) * amplitude;
+          maxValue += amplitude;
+          amplitude *= 0.5;
+          frequency *= 2;
+        }
+        noiseValue = (noiseValue / maxValue + 1) * 0.5;
+        const flameIntensity = noiseValue * heightFactor * this._intensity;
+        if (flameIntensity > 0) {
+          const colorIndex = (y * width + x) * 4;
+          let r, g, b;
+          if (flameIntensity > 0.7) {
+            r = 1;
+            g = 1;
+            b = 0.3 + (flameIntensity - 0.7) * 2.3;
+          } else if (flameIntensity > 0.4) {
+            r = 1;
+            g = 0.5 + (flameIntensity - 0.4) * 1.67;
+            b = 0;
+          } else {
+            r = 0.3 + flameIntensity * 1.75;
+            g = flameIntensity * 0.5;
+            b = 0;
+          }
+          bg2[colorIndex] = Math.max(bg2[colorIndex], r * flameIntensity);
+          bg2[colorIndex + 1] = Math.max(bg2[colorIndex + 1], g * flameIntensity);
+          bg2[colorIndex + 2] = Math.max(bg2[colorIndex + 2], b * flameIntensity);
+        }
+      }
+    }
+  }
+}
+
+class CRTRollingBarEffect {
+  _speed;
+  _height;
+  _intensity;
+  _fadeDistance;
+  position = 0;
+  constructor(speed = 0.5, height = 0.15, intensity = 0.3, fadeDistance = 0.3) {
+    this._speed = speed;
+    this._height = Math.max(0.01, Math.min(0.5, height));
+    this._intensity = Math.max(0, Math.min(1, intensity));
+    this._fadeDistance = Math.max(0, Math.min(1, fadeDistance));
+  }
+  set speed(newSpeed) {
+    this._speed = newSpeed;
+  }
+  get speed() {
+    return this._speed;
+  }
+  set height(newHeight) {
+    this._height = Math.max(0.01, Math.min(0.5, newHeight));
+  }
+  get height() {
+    return this._height;
+  }
+  set intensity(newIntensity) {
+    this._intensity = Math.max(0, Math.min(1, newIntensity));
+  }
+  get intensity() {
+    return this._intensity;
+  }
+  set fadeDistance(newFadeDistance) {
+    this._fadeDistance = Math.max(0, Math.min(1, newFadeDistance));
+  }
+  get fadeDistance() {
+    return this._fadeDistance;
+  }
+  apply(buffer, deltaTime) {
+    const width = buffer.width;
+    const height = buffer.height;
+    const fg2 = buffer.buffers.fg;
+    const bg2 = buffer.buffers.bg;
+    this.position += deltaTime / 1000 * this._speed;
+    const cycleHeight = height + this._height * height * 2;
+    this.position = this.position % cycleHeight;
+    const barPixelHeight = this._height * height;
+    const fadePixelDistance = this._fadeDistance * barPixelHeight;
+    const totalEffectHeight = barPixelHeight + fadePixelDistance * 2;
+    const effectCenter = this.position - totalEffectHeight / 2 + barPixelHeight / 2;
+    for (let y = 0;y < height; y++) {
+      const distFromCenter = Math.abs(y - effectCenter);
+      let barFactor = 0;
+      if (distFromCenter <= totalEffectHeight / 2) {
+        const normalizedDist = distFromCenter / (totalEffectHeight / 2);
+        barFactor = Math.cos(normalizedDist * Math.PI / 2);
+      }
+      if (barFactor > 0.001) {
+        const rowMultiplier = 1 + this._intensity * barFactor;
+        for (let x = 0;x < width; x++) {
+          const colorIndex = (y * width + x) * 4;
+          fg2[colorIndex] = Math.min(1, fg2[colorIndex] * rowMultiplier);
+          fg2[colorIndex + 1] = Math.min(1, fg2[colorIndex + 1] * rowMultiplier);
+          fg2[colorIndex + 2] = Math.min(1, fg2[colorIndex + 2] * rowMultiplier);
+          bg2[colorIndex] = Math.min(1, bg2[colorIndex] * rowMultiplier);
+          bg2[colorIndex + 1] = Math.min(1, bg2[colorIndex + 1] * rowMultiplier);
+          bg2[colorIndex + 2] = Math.min(1, bg2[colorIndex + 2] * rowMultiplier);
+        }
+      }
+    }
+  }
+}
+
+class RainbowTextEffect {
+  _speed;
+  _saturation;
+  _value;
+  _repeats;
+  time = 0;
+  constructor(speed = 0.01, saturation = 1, value = 1, repeats = 3) {
+    this._speed = speed;
+    this._saturation = saturation;
+    this._value = value;
+    this._repeats = repeats;
+  }
+  set speed(newSpeed) {
+    this._speed = Math.max(0, newSpeed);
+  }
+  get speed() {
+    return this._speed;
+  }
+  set saturation(newSaturation) {
+    this._saturation = Math.max(0, Math.min(1, newSaturation));
+  }
+  get saturation() {
+    return this._saturation;
+  }
+  set value(newValue) {
+    this._value = Math.max(0, Math.min(1, newValue));
+  }
+  get value() {
+    return this._value;
+  }
+  set repeats(newRepeats) {
+    this._repeats = Math.max(0.1, newRepeats);
+  }
+  get repeats() {
+    return this._repeats;
+  }
+  hsvToRgb(h2, s, v) {
+    let r = 0, g = 0, b = 0;
+    const i = Math.floor(h2 * 6);
+    const f = h2 * 6 - i;
+    const p = v * (1 - s);
+    const q = v * (1 - f * s);
+    const t2 = v * (1 - (1 - f) * s);
+    switch (i % 6) {
+      case 0:
+        r = v;
+        g = t2;
+        b = p;
+        break;
+      case 1:
+        r = q;
+        g = v;
+        b = p;
+        break;
+      case 2:
+        r = p;
+        g = v;
+        b = t2;
+        break;
+      case 3:
+        r = p;
+        g = q;
+        b = v;
+        break;
+      case 4:
+        r = t2;
+        g = p;
+        b = v;
+        break;
+      case 5:
+        r = v;
+        g = p;
+        b = q;
+        break;
+    }
+    return [r, g, b];
+  }
+  apply(buffer, deltaTime) {
+    const width = buffer.width;
+    const height = buffer.height;
+    const fg2 = buffer.buffers.fg;
+    this.time += deltaTime * this._speed;
+    const saturation = this._saturation;
+    const value = this._value;
+    const repeats = this._repeats;
+    const angleRad = 25 * Math.PI / 180;
+    const cosAngle = Math.cos(angleRad);
+    const sinAngle = Math.sin(angleRad);
+    const whiteThreshold = 0.9;
+    for (let y = 0;y < height; y++) {
+      for (let x = 0;x < width; x++) {
+        const colorIndex = (y * width + x) * 4;
+        const r = fg2[colorIndex];
+        const g = fg2[colorIndex + 1];
+        const b = fg2[colorIndex + 2];
+        if (r >= whiteThreshold && g >= whiteThreshold && b >= whiteThreshold) {
+          const projection = x * cosAngle + y * sinAngle;
+          const maxProjection = width * cosAngle + height * sinAngle;
+          const hue = (projection / maxProjection * repeats + this.time * 0.1) % 1;
+          const [newR, newG, newB] = this.hsvToRgb(hue, saturation, value);
+          fg2[colorIndex] = newR;
+          fg2[colorIndex + 1] = newG;
+          fg2[colorIndex + 2] = newB;
+        }
+      }
+    }
+  }
+}
 // src/post/filters.ts
 function applyScanlines(buffer, strength = 0.8, step = 2) {
   if (strength === 1 || step < 1)
@@ -1564,6 +2214,259 @@ class BloomEffect {
     }
   }
 }
+// src/post/matrices.ts
+var SEPIA_MATRIX = new Float32Array([
+  0.393,
+  0.769,
+  0.189,
+  0,
+  0.349,
+  0.686,
+  0.168,
+  0,
+  0.272,
+  0.534,
+  0.131,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+var PROTANOPIA_SIM_MATRIX = new Float32Array([
+  0.567,
+  0.433,
+  0,
+  0,
+  0.558,
+  0.442,
+  0,
+  0,
+  0,
+  0.242,
+  0.758,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+var DEUTERANOPIA_SIM_MATRIX = new Float32Array([
+  0.625,
+  0.375,
+  0,
+  0,
+  0.7,
+  0.3,
+  0,
+  0,
+  0,
+  0.3,
+  0.7,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+var TRITANOPIA_SIM_MATRIX = new Float32Array([
+  0.95,
+  0.05,
+  0,
+  0,
+  0,
+  0.433,
+  0.567,
+  0,
+  0,
+  0.475,
+  0.525,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+var ACHROMATOPSIA_MATRIX = new Float32Array([
+  0.299,
+  0.587,
+  0.114,
+  0,
+  0.299,
+  0.587,
+  0.114,
+  0,
+  0.299,
+  0.587,
+  0.114,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+var PROTANOPIA_COMP_MATRIX = new Float32Array([
+  1,
+  0.2,
+  0,
+  0,
+  0,
+  0.9,
+  0.1,
+  0,
+  0,
+  0.1,
+  0.9,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+var DEUTERANOPIA_COMP_MATRIX = new Float32Array([
+  0.9,
+  0.1,
+  0,
+  0,
+  0.2,
+  0.8,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+var TRITANOPIA_COMP_MATRIX = new Float32Array([
+  1,
+  0,
+  0,
+  0,
+  0,
+  0.9,
+  0.1,
+  0,
+  0.1,
+  0,
+  0.9,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+var TECHNICOLOR_MATRIX = new Float32Array([
+  1.5,
+  -0.2,
+  -0.3,
+  0,
+  -0.3,
+  1.4,
+  -0.1,
+  0,
+  -0.2,
+  -0.2,
+  1.4,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+var SOLARIZATION_MATRIX = new Float32Array([
+  -0.5,
+  0.5,
+  0.5,
+  0,
+  0.5,
+  -0.5,
+  0.5,
+  0,
+  0.5,
+  0.5,
+  -0.5,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+var SYNTHWAVE_MATRIX = new Float32Array([
+  1,
+  0,
+  0.25,
+  0,
+  0.1,
+  0.1,
+  0.1,
+  0,
+  0.25,
+  0,
+  1,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+var GREENSCALE_MATRIX = new Float32Array([
+  0,
+  0,
+  0,
+  0,
+  0.299,
+  0.587,
+  0.114,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+var GRAYSCALE_MATRIX = new Float32Array([
+  0.299,
+  0.587,
+  0.114,
+  0,
+  0.299,
+  0.587,
+  0.114,
+  0,
+  0.299,
+  0.587,
+  0.114,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+var INVERT_MATRIX = new Float32Array([
+  -1,
+  0,
+  0,
+  1,
+  0,
+  -1,
+  0,
+  1,
+  0,
+  0,
+  -1,
+  1,
+  0,
+  0,
+  0,
+  1
+]);
 // src/animation/Timeline.ts
 var easingFunctions = {
   linear: (t2) => t2,
@@ -12367,7 +13270,7 @@ class TimeToFirstDrawRenderable extends Renderable {
     return Math.max(0, Math.floor(value));
   }
 }
-export { TextBufferView, EditBuffer, EditorView, convertThemeToStyles, SyntaxStyle, applyScanlines, applyInvert, applyNoise, applyChromaticAberration, applyAsciiArt, applyBrightness, applyGain, applySaturation, BloomEffect, Timeline, engine, createTimeline, SlotRegistry, createSlotRegistry, createCoreSlotRegistry, registerCorePlugin, resolveCoreSlot, SlotRenderable, NativeSpanFeed, FrameBufferRenderable, ASCIIFontRenderable, BoxRenderable, TextBufferRenderable, CodeRenderable, isTextNodeRenderable, TextNodeRenderable, RootTextNodeRenderable, Generic, Box, Text, ASCIIFont, Input, Select, TabSelect, FrameBuffer, Code, ScrollBox, vstyles, VRenderable, LineNumberRenderable, TextRenderable, DiffRenderable, TextareaRenderable, InputRenderableEvents, InputRenderable, TextTableRenderable, MarkdownRenderable, SliderRenderable, ScrollBarRenderable, ArrowRenderable, ScrollBoxRenderable, SelectRenderableEvents, SelectRenderable, TabSelectRenderableEvents, TabSelectRenderable, TimeToFirstDrawRenderable, exports_src2 as exports_src };
+export { TextBufferView, EditBuffer, EditorView, convertThemeToStyles, SyntaxStyle, DistortionEffect, VignetteEffect, CloudsEffect, FlamesEffect, CRTRollingBarEffect, RainbowTextEffect, applyScanlines, applyInvert, applyNoise, applyChromaticAberration, applyAsciiArt, applyBrightness, applyGain, applySaturation, BloomEffect, SEPIA_MATRIX, PROTANOPIA_SIM_MATRIX, DEUTERANOPIA_SIM_MATRIX, TRITANOPIA_SIM_MATRIX, ACHROMATOPSIA_MATRIX, PROTANOPIA_COMP_MATRIX, DEUTERANOPIA_COMP_MATRIX, TRITANOPIA_COMP_MATRIX, TECHNICOLOR_MATRIX, SOLARIZATION_MATRIX, SYNTHWAVE_MATRIX, GREENSCALE_MATRIX, GRAYSCALE_MATRIX, INVERT_MATRIX, Timeline, engine, createTimeline, SlotRegistry, createSlotRegistry, createCoreSlotRegistry, registerCorePlugin, resolveCoreSlot, SlotRenderable, NativeSpanFeed, FrameBufferRenderable, ASCIIFontRenderable, BoxRenderable, TextBufferRenderable, CodeRenderable, isTextNodeRenderable, TextNodeRenderable, RootTextNodeRenderable, Generic, Box, Text, ASCIIFont, Input, Select, TabSelect, FrameBuffer, Code, ScrollBox, vstyles, VRenderable, LineNumberRenderable, TextRenderable, DiffRenderable, TextareaRenderable, InputRenderableEvents, InputRenderable, TextTableRenderable, MarkdownRenderable, SliderRenderable, ScrollBarRenderable, ArrowRenderable, ScrollBoxRenderable, SelectRenderableEvents, SelectRenderable, TabSelectRenderableEvents, TabSelectRenderable, TimeToFirstDrawRenderable, exports_src2 as exports_src };
 
-//# debugId=DC05962D46EF296364756E2164756E21
-//# sourceMappingURL=index-rs5zwr4j.js.map
+//# debugId=22B8DF0D4AE1971464756E2164756E21
+//# sourceMappingURL=index-k03avn41.js.map