@opentui/core 0.1.88 → 0.1.90

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

@@ -37,6 +37,7 @@ import {
   StdinParser,
   StyledText,
   SystemClock,
+  TargetChannel,
   TerminalConsole,
   TerminalPalette,
   TextAttributes,
@@ -45,6 +46,7 @@ import {
   __export,
   addDefaultParsers,
   attributesWithLink,
+  basenameToFiletype,
   bg,
   bgBlack,
   bgBlue,
@@ -87,6 +89,7 @@ import {
   envRegistry,
   exports_src,
   extToFiletype,
+  extensionToFiletype,
   fg,
   fonts,
   generateEnvColored,
@@ -105,6 +108,7 @@ import {
   hastToStyledText,
   hexToRgb,
   hsvToRgb,
+  infoStringToFiletype,
   instantiate,
   isRenderable,
   isStyledText,
@@ -158,7 +162,7 @@ import {
   white,
   wrapWithDelegates,
   yellow
-} from "./index-nkrr8a4c.js";
+} from "./index-e89anq5x.js";
 
 // src/index.ts
 var exports_src2 = {};
@@ -217,6 +221,7 @@ __export(exports_src2, {
   isStyledText: () => isStyledText,
   isRenderable: () => isRenderable,
   instantiate: () => instantiate,
+  infoStringToFiletype: () => infoStringToFiletype,
   hsvToRgb: () => hsvToRgb,
   hexToRgb: () => hexToRgb,
   hastToStyledText: () => hastToStyledText,
@@ -233,6 +238,7 @@ __export(exports_src2, {
   generateEnvColored: () => generateEnvColored,
   fonts: () => fonts,
   fg: () => fg,
+  extensionToFiletype: () => extensionToFiletype,
   extToFiletype: () => extToFiletype,
   envRegistry: () => envRegistry,
   env: () => env,
@@ -277,13 +283,15 @@ __export(exports_src2, {
   bgBlue: () => bgBlue,
   bgBlack: () => bgBlack,
   bg: () => bg,
+  basenameToFiletype: () => basenameToFiletype,
   attributesWithLink: () => attributesWithLink,
-  applySepia: () => applySepia,
   applyScanlines: () => applyScanlines,
+  applySaturation: () => applySaturation,
   applyNoise: () => applyNoise,
   applyInvert: () => applyInvert,
-  applyGrayscale: () => applyGrayscale,
+  applyGain: () => applyGain,
   applyChromaticAberration: () => applyChromaticAberration,
+  applyBrightness: () => applyBrightness,
   applyAsciiArt: () => applyAsciiArt,
   addDefaultParsers: () => addDefaultParsers,
   Yoga: () => exports_src,
@@ -303,9 +311,13 @@ __export(exports_src2, {
   Text: () => Text,
   TerminalPalette: () => TerminalPalette,
   TerminalConsole: () => TerminalConsole,
+  TargetChannel: () => TargetChannel,
   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,
@@ -320,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,
@@ -344,9 +362,13 @@ __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,
@@ -354,17 +376,19 @@ __export(exports_src2, {
   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,
-  BrightnessEffect: () => BrightnessEffect,
+  CRTRollingBarEffect: () => CRTRollingBarEffect,
   BoxRenderable: () => BoxRenderable,
   Box: () => Box,
   BorderChars: () => BorderChars,
   BorderCharArrays: () => BorderCharArrays,
-  BlurEffect: () => BlurEffect,
   BloomEffect: () => BloomEffect,
   BaseRenderable: () => BaseRenderable,
   ArrowRenderable: () => ArrowRenderable,
@@ -372,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
@@ -1197,141 +1222,7 @@ class SyntaxStyle {
     this.lib.destroySyntaxStyle(this.stylePtr);
   }
 }
-// src/post/filters.ts
-function applyScanlines(buffer, strength = 0.8, step = 2) {
-  const width = buffer.width;
-  const height = buffer.height;
-  const bg2 = buffer.buffers.bg;
-  for (let y = 0;y < height; y += step) {
-    for (let x = 0;x < width; x++) {
-      const colorIndex = (y * width + x) * 4;
-      bg2[colorIndex] *= strength;
-      bg2[colorIndex + 1] *= strength;
-      bg2[colorIndex + 2] *= strength;
-    }
-  }
-}
-function applyGrayscale(buffer) {
-  const size = buffer.width * buffer.height;
-  const fg2 = buffer.buffers.fg;
-  const bg2 = buffer.buffers.bg;
-  for (let i = 0;i < size; i++) {
-    const colorIndex = i * 4;
-    const fgR = fg2[colorIndex];
-    const fgG = fg2[colorIndex + 1];
-    const fgB = fg2[colorIndex + 2];
-    const fgLum = 0.299 * fgR + 0.587 * fgG + 0.114 * fgB;
-    fg2[colorIndex] = fgLum;
-    fg2[colorIndex + 1] = fgLum;
-    fg2[colorIndex + 2] = fgLum;
-    const bgR = bg2[colorIndex];
-    const bgG = bg2[colorIndex + 1];
-    const bgB = bg2[colorIndex + 2];
-    const bgLum = 0.299 * bgR + 0.587 * bgG + 0.114 * bgB;
-    bg2[colorIndex] = bgLum;
-    bg2[colorIndex + 1] = bgLum;
-    bg2[colorIndex + 2] = bgLum;
-  }
-}
-function applySepia(buffer) {
-  const size = buffer.width * buffer.height;
-  const fg2 = buffer.buffers.fg;
-  const bg2 = buffer.buffers.bg;
-  for (let i = 0;i < size; i++) {
-    const colorIndex = i * 4;
-    let fgR = fg2[colorIndex];
-    let fgG = fg2[colorIndex + 1];
-    let fgB = fg2[colorIndex + 2];
-    let newFgR = Math.min(1, fgR * 0.393 + fgG * 0.769 + fgB * 0.189);
-    let newFgG = Math.min(1, fgR * 0.349 + fgG * 0.686 + fgB * 0.168);
-    let newFgB = Math.min(1, fgR * 0.272 + fgG * 0.534 + fgB * 0.131);
-    fg2[colorIndex] = newFgR;
-    fg2[colorIndex + 1] = newFgG;
-    fg2[colorIndex + 2] = newFgB;
-    let bgR = bg2[colorIndex];
-    let bgG = bg2[colorIndex + 1];
-    let bgB = bg2[colorIndex + 2];
-    let newBgR = Math.min(1, bgR * 0.393 + bgG * 0.769 + bgB * 0.189);
-    let newBgG = Math.min(1, bgR * 0.349 + bgG * 0.686 + bgB * 0.168);
-    let newBgB = Math.min(1, bgR * 0.272 + bgG * 0.534 + bgB * 0.131);
-    bg2[colorIndex] = newBgR;
-    bg2[colorIndex + 1] = newBgG;
-    bg2[colorIndex + 2] = newBgB;
-  }
-}
-function applyInvert(buffer) {
-  const size = buffer.width * buffer.height;
-  const fg2 = buffer.buffers.fg;
-  const bg2 = buffer.buffers.bg;
-  for (let i = 0;i < size; i++) {
-    const colorIndex = i * 4;
-    fg2[colorIndex] = 1 - fg2[colorIndex];
-    fg2[colorIndex + 1] = 1 - fg2[colorIndex + 1];
-    fg2[colorIndex + 2] = 1 - fg2[colorIndex + 2];
-    bg2[colorIndex] = 1 - bg2[colorIndex];
-    bg2[colorIndex + 1] = 1 - bg2[colorIndex + 1];
-    bg2[colorIndex + 2] = 1 - bg2[colorIndex + 2];
-  }
-}
-function applyNoise(buffer, strength = 0.1) {
-  const size = buffer.width * buffer.height;
-  const fg2 = buffer.buffers.fg;
-  const bg2 = buffer.buffers.bg;
-  for (let i = 0;i < size; i++) {
-    const colorIndex = i * 4;
-    const noise = (Math.random() - 0.5) * strength;
-    fg2[colorIndex] = Math.max(0, Math.min(1, fg2[colorIndex] + noise));
-    fg2[colorIndex + 1] = Math.max(0, Math.min(1, fg2[colorIndex + 1] + noise));
-    fg2[colorIndex + 2] = Math.max(0, Math.min(1, fg2[colorIndex + 2] + noise));
-    bg2[colorIndex] = Math.max(0, Math.min(1, bg2[colorIndex] + noise));
-    bg2[colorIndex + 1] = Math.max(0, Math.min(1, bg2[colorIndex + 1] + noise));
-    bg2[colorIndex + 2] = Math.max(0, Math.min(1, bg2[colorIndex + 2] + noise));
-  }
-}
-function applyChromaticAberration(buffer, strength = 1) {
-  const width = buffer.width;
-  const height = buffer.height;
-  const srcFg = Float32Array.from(buffer.buffers.fg);
-  const destFg = buffer.buffers.fg;
-  const centerX = width / 2;
-  const centerY = height / 2;
-  for (let y = 0;y < height; y++) {
-    for (let x = 0;x < width; x++) {
-      const dx = x - centerX;
-      const dy = y - centerY;
-      const offset = Math.round(Math.sqrt(dx * dx + dy * dy) / Math.max(centerX, centerY) * strength);
-      const rX = Math.max(0, Math.min(width - 1, x - offset));
-      const bX = Math.max(0, Math.min(width - 1, x + offset));
-      const rIndex = (y * width + rX) * 4;
-      const gIndex = (y * width + x) * 4;
-      const bIndex = (y * width + bX) * 4;
-      const destIndex = (y * width + x) * 4;
-      destFg[destIndex] = srcFg[rIndex];
-      destFg[destIndex + 1] = srcFg[gIndex + 1];
-      destFg[destIndex + 2] = srcFg[bIndex + 2];
-    }
-  }
-}
-function applyAsciiArt(buffer, ramp = " .:-=+*#%@") {
-  const width = buffer.width;
-  const height = buffer.height;
-  const chars = buffer.buffers.char;
-  const bg2 = buffer.buffers.bg;
-  const rampLength = ramp.length;
-  for (let y = 0;y < height; y++) {
-    for (let x = 0;x < width; x++) {
-      const index = y * width + x;
-      const colorIndex = index * 4;
-      const bgR = bg2[colorIndex];
-      const bgG = bg2[colorIndex + 1];
-      const bgB = bg2[colorIndex + 2];
-      const lum = 0.299 * bgR + 0.587 * bgG + 0.114 * bgB;
-      const rampIndex = Math.min(rampLength - 1, Math.floor(lum * rampLength));
-      chars[index] = ramp[rampIndex].charCodeAt(0);
-    }
-  }
-}
-
+// src/post/effects.ts
 class DistortionEffect {
   glitchChancePerSecond = 0.5;
   maxGlitchLines = 3;
@@ -1518,24 +1409,30 @@ class DistortionEffect {
 
 class VignetteEffect {
   _strength;
-  precomputedBaseAttenuation = null;
+  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.precomputedBaseAttenuation = new Float32Array(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;
@@ -1543,8 +1440,10 @@ class VignetteEffect {
         const dx = x - centerX;
         const distSq = dx * dx + dySq;
         const baseAttenuation = Math.min(1, distSq / safeMaxDistSq);
-        const index = y * width + x;
-        this.precomputedBaseAttenuation[index] = baseAttenuation;
+        const attenuation = baseAttenuation * strength;
+        this.precomputedAttenuationCellMask[i++] = x;
+        this.precomputedAttenuationCellMask[i++] = y;
+        this.precomputedAttenuationCellMask[i++] = attenuation;
       }
     }
     this.cachedWidth = width;
@@ -1553,215 +1452,683 @@ class VignetteEffect {
   apply(buffer) {
     const width = buffer.width;
     const height = buffer.height;
-    const buf = buffer.buffers;
-    const size = width * height;
-    if (width !== this.cachedWidth || height !== this.cachedHeight || !this.precomputedBaseAttenuation) {
+    if (width !== this.cachedWidth || height !== this.cachedHeight || !this.precomputedAttenuationCellMask) {
       this._computeFactors(width, height);
     }
-    for (let i = 0;i < size; i++) {
-      const factor = Math.max(0, 1 - this.precomputedBaseAttenuation[i] * this._strength);
-      const colorIndex = i * 4;
-      buf.fg[colorIndex] *= factor;
-      buf.fg[colorIndex + 1] *= factor;
-      buf.fg[colorIndex + 2] *= factor;
-      buf.bg[colorIndex] *= factor;
-      buf.bg[colorIndex + 1] *= factor;
-      buf.bg[colorIndex + 2] *= factor;
-    }
+    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 BrightnessEffect {
-  _brightness;
-  constructor(brightness = 1) {
-    this._brightness = Math.max(0, brightness);
+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 brightness(newBrightness) {
-    this._brightness = Math.max(0, newBrightness);
+  set scale(newScale) {
+    this._scale = Math.max(0.001, newScale);
   }
-  get brightness() {
-    return this._brightness;
+  get scale() {
+    return this._scale;
   }
-  apply(buffer) {
-    const size = buffer.width * buffer.height;
-    const fg2 = buffer.buffers.fg;
+  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;
-    const factor = this._brightness;
-    if (factor === 1) {
-      return;
-    }
-    for (let i = 0;i < size; i++) {
-      const colorIndex = i * 4;
-      fg2[colorIndex] = Math.min(1, fg2[colorIndex] * factor);
-      fg2[colorIndex + 1] = Math.min(1, fg2[colorIndex + 1] * factor);
-      fg2[colorIndex + 2] = Math.min(1, fg2[colorIndex + 2] * factor);
-      bg2[colorIndex] = Math.min(1, bg2[colorIndex] * factor);
-      bg2[colorIndex + 1] = Math.min(1, bg2[colorIndex + 1] * factor);
-      bg2[colorIndex + 2] = Math.min(1, bg2[colorIndex + 2] * factor);
+    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 BlurEffect {
-  _radius;
-  constructor(radius = 1) {
-    this._radius = Math.max(0, Math.round(radius));
+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 radius(newRadius) {
-    this._radius = Math.max(0, Math.round(newRadius));
+  set speed(newSpeed) {
+    this._speed = newSpeed;
   }
-  get radius() {
-    return this._radius;
+  get speed() {
+    return this._speed;
   }
-  apply(buffer) {
-    const radius = this._radius;
-    if (radius <= 0)
-      return;
+  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 buf = buffer.buffers;
-    const srcFg = buf.fg;
-    const srcBg = buf.bg;
-    const destFg = buf.fg;
-    const destBg = buf.bg;
-    const chars = buf.char;
-    const size = width * height;
-    const numChannels = 4;
-    const tempBufferFg = new Float32Array(size * numChannels);
-    const tempBufferBg = new Float32Array(size * numChannels);
-    const windowSize = radius * 2 + 1;
+    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++) {
-      let sumR = 0, sumG = 0, sumB = 0, sumA = 0;
-      const baseRowIndex = y * width;
-      for (let x = -radius;x <= radius; x++) {
-        const sampleX = Math.max(0, Math.min(width - 1, x));
-        const srcIndex = (baseRowIndex + sampleX) * numChannels;
-        sumR += srcFg[srcIndex];
-        sumG += srcFg[srcIndex + 1];
-        sumB += srcFg[srcIndex + 2];
-        sumA += srcFg[srcIndex + 3];
+      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);
       }
-      for (let x = 0;x < width; x++) {
-        const destIndex = (baseRowIndex + x) * numChannels;
-        tempBufferFg[destIndex] = sumR / windowSize;
-        tempBufferFg[destIndex + 1] = sumG / windowSize;
-        tempBufferFg[destIndex + 2] = sumB / windowSize;
-        tempBufferFg[destIndex + 3] = sumA / windowSize;
-        const leavingX = Math.max(0, Math.min(width - 1, x - radius));
-        const leavingIndex = (baseRowIndex + leavingX) * numChannels;
-        sumR -= srcFg[leavingIndex];
-        sumG -= srcFg[leavingIndex + 1];
-        sumB -= srcFg[leavingIndex + 2];
-        sumA -= srcFg[leavingIndex + 3];
-        const enteringX = Math.max(0, Math.min(width - 1, x + radius + 1));
-        const enteringIndex = (baseRowIndex + enteringX) * numChannels;
-        sumR += srcFg[enteringIndex];
-        sumG += srcFg[enteringIndex + 1];
-        sumB += srcFg[enteringIndex + 2];
-        sumA += srcFg[enteringIndex + 3];
+      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++) {
-      let sumR = 0, sumG = 0, sumB = 0, sumA = 0;
-      const baseRowIndex = y * width;
-      for (let x = -radius;x <= radius; x++) {
-        const sampleX = Math.max(0, Math.min(width - 1, x));
-        const srcIndex = (baseRowIndex + sampleX) * numChannels;
-        sumR += srcBg[srcIndex];
-        sumG += srcBg[srcIndex + 1];
-        sumB += srcBg[srcIndex + 2];
-        sumA += srcBg[srcIndex + 3];
-      }
       for (let x = 0;x < width; x++) {
-        const destIndex = (baseRowIndex + x) * numChannels;
-        tempBufferBg[destIndex] = sumR / windowSize;
-        tempBufferBg[destIndex + 1] = sumG / windowSize;
-        tempBufferBg[destIndex + 2] = sumB / windowSize;
-        tempBufferBg[destIndex + 3] = sumA / windowSize;
-        const leavingX = Math.max(0, Math.min(width - 1, x - radius));
-        const leavingIndex = (baseRowIndex + leavingX) * numChannels;
-        sumR -= srcBg[leavingIndex];
-        sumG -= srcBg[leavingIndex + 1];
-        sumB -= srcBg[leavingIndex + 2];
-        sumA -= srcBg[leavingIndex + 3];
-        const enteringX = Math.max(0, Math.min(width - 1, x + radius + 1));
-        const enteringIndex = (baseRowIndex + enteringX) * numChannels;
-        sumR += srcBg[enteringIndex];
-        sumG += srcBg[enteringIndex + 1];
-        sumB += srcBg[enteringIndex + 2];
-        sumA += srcBg[enteringIndex + 3];
+        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)
+    return;
+  const width = buffer.width;
+  const height = buffer.height;
+  const affectedRows = Math.ceil(height / step);
+  const cellCount = width * affectedRows;
+  const cellMask = new Float32Array(cellCount * 3);
+  let maskIdx = 0;
+  for (let y = 0;y < height; y += step) {
     for (let x = 0;x < width; x++) {
-      let sumR = 0, sumG = 0, sumB = 0, sumA = 0;
-      for (let y = -radius;y <= radius; y++) {
-        const sampleY = Math.max(0, Math.min(height - 1, y));
-        const srcIndex = (sampleY * width + x) * numChannels;
-        sumR += tempBufferFg[srcIndex];
-        sumG += tempBufferFg[srcIndex + 1];
-        sumB += tempBufferFg[srcIndex + 2];
-        sumA += tempBufferFg[srcIndex + 3];
-      }
-      for (let y = 0;y < height; y++) {
-        const destIndex = (y * width + x) * numChannels;
-        destFg[destIndex] = sumR / windowSize;
-        destFg[destIndex + 1] = sumG / windowSize;
-        destFg[destIndex + 2] = sumB / windowSize;
-        destFg[destIndex + 3] = sumA / windowSize;
-        const leavingY = Math.max(0, Math.min(height - 1, y - radius));
-        const leavingIndex = (leavingY * width + x) * numChannels;
-        sumR -= tempBufferFg[leavingIndex];
-        sumG -= tempBufferFg[leavingIndex + 1];
-        sumB -= tempBufferFg[leavingIndex + 2];
-        sumA -= tempBufferFg[leavingIndex + 3];
-        const enteringY = Math.max(0, Math.min(height - 1, y + radius + 1));
-        const enteringIndex = (enteringY * width + x) * numChannels;
-        sumR += tempBufferFg[enteringIndex];
-        sumG += tempBufferFg[enteringIndex + 1];
-        sumB += tempBufferFg[enteringIndex + 2];
-        sumA += tempBufferFg[enteringIndex + 3];
-      }
+      cellMask[maskIdx++] = x;
+      cellMask[maskIdx++] = y;
+      cellMask[maskIdx++] = 1;
+    }
+  }
+  const s = strength;
+  const matrix = new Float32Array([
+    s,
+    0,
+    0,
+    0,
+    0,
+    s,
+    0,
+    0,
+    0,
+    0,
+    s,
+    0,
+    0,
+    0,
+    0,
+    1
+  ]);
+  buffer.colorMatrix(matrix, cellMask, 1, 2);
+}
+function applyInvert(buffer, strength = 1) {
+  if (strength === 0)
+    return;
+  const matrix = new Float32Array([
+    -1,
+    0,
+    0,
+    1,
+    0,
+    -1,
+    0,
+    1,
+    0,
+    0,
+    -1,
+    1,
+    0,
+    0,
+    0,
+    1
+  ]);
+  buffer.colorMatrixUniform(matrix, strength, 3);
+}
+function applyNoise(buffer, strength = 0.1) {
+  const width = buffer.width;
+  const height = buffer.height;
+  const size = width * height;
+  if (strength === 0)
+    return;
+  const cellMask = new Float32Array(size * 3);
+  let cellMaskIndex = 0;
+  for (let y = 0;y < height; y++) {
+    for (let x = 0;x < width; x++) {
+      cellMask[cellMaskIndex++] = x;
+      cellMask[cellMaskIndex++] = y;
+      cellMask[cellMaskIndex++] = (Math.random() - 0.5) * 2;
+    }
+  }
+  const b = 1 + strength;
+  const matrix = new Float32Array([
+    b,
+    0,
+    0,
+    0,
+    0,
+    b,
+    0,
+    0,
+    0,
+    0,
+    b,
+    0,
+    0,
+    0,
+    0,
+    1
+  ]);
+  buffer.colorMatrix(matrix, cellMask, 1, 3);
+}
+function applyChromaticAberration(buffer, strength = 1) {
+  const width = buffer.width;
+  const height = buffer.height;
+  const srcFg = Float32Array.from(buffer.buffers.fg);
+  const destFg = buffer.buffers.fg;
+  const centerX = width / 2;
+  const centerY = height / 2;
+  for (let y = 0;y < height; y++) {
+    for (let x = 0;x < width; x++) {
+      const dx = x - centerX;
+      const dy = y - centerY;
+      const offset = Math.round(Math.sqrt(dx * dx + dy * dy) / Math.max(centerX, centerY) * strength);
+      const rX = Math.max(0, Math.min(width - 1, x - offset));
+      const bX = Math.max(0, Math.min(width - 1, x + offset));
+      const rIndex = (y * width + rX) * 4;
+      const gIndex = (y * width + x) * 4;
+      const bIndex = (y * width + bX) * 4;
+      const destIndex = (y * width + x) * 4;
+      destFg[destIndex] = srcFg[rIndex];
+      destFg[destIndex + 1] = srcFg[gIndex + 1];
+      destFg[destIndex + 2] = srcFg[bIndex + 2];
     }
+  }
+}
+function applyAsciiArt(buffer, ramp = ' .\'`^"",:;Il!i><~+_-?][}{1)(|\\/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$', fgColor = { r: 1, g: 1, b: 1 }, bgColor = { r: 0, g: 0, b: 0 }) {
+  const width = buffer.width;
+  const height = buffer.height;
+  const chars = buffer.buffers.char;
+  const bg2 = buffer.buffers.bg;
+  const rampLength = ramp.length;
+  for (let y = 0;y < height; y++) {
     for (let x = 0;x < width; x++) {
-      let sumR = 0, sumG = 0, sumB = 0, sumA = 0;
-      for (let y = -radius;y <= radius; y++) {
-        const sampleY = Math.max(0, Math.min(height - 1, y));
-        const srcIndex = (sampleY * width + x) * numChannels;
-        sumR += tempBufferBg[srcIndex];
-        sumG += tempBufferBg[srcIndex + 1];
-        sumB += tempBufferBg[srcIndex + 2];
-        sumA += tempBufferBg[srcIndex + 3];
-      }
-      for (let y = 0;y < height; y++) {
-        const destIndex = (y * width + x) * numChannels;
-        destBg[destIndex] = sumR / windowSize;
-        destBg[destIndex + 1] = sumG / windowSize;
-        destBg[destIndex + 2] = sumB / windowSize;
-        destBg[destIndex + 3] = sumA / windowSize;
-        const leavingY = Math.max(0, Math.min(height - 1, y - radius));
-        const leavingIndex = (leavingY * width + x) * numChannels;
-        sumR -= tempBufferBg[leavingIndex];
-        sumG -= tempBufferBg[leavingIndex + 1];
-        sumB -= tempBufferBg[leavingIndex + 2];
-        sumA -= tempBufferBg[leavingIndex + 3];
-        const enteringY = Math.max(0, Math.min(height - 1, y + radius + 1));
-        const enteringIndex = (enteringY * width + x) * numChannels;
-        sumR += tempBufferBg[enteringIndex];
-        sumG += tempBufferBg[enteringIndex + 1];
-        sumB += tempBufferBg[enteringIndex + 2];
-        sumA += tempBufferBg[enteringIndex + 3];
-      }
-    }
-    const charRamp = [" ", "\u2591", "\u2592", "\u2593", " "];
-    const rampLength = charRamp.length;
-    for (let i = 0;i < size; i++) {
-      const alphaIndex = i * numChannels + 3;
-      const fgAlpha = destFg[alphaIndex];
-      const clampedAlpha = Math.max(0, Math.min(1, fgAlpha));
-      const rampIndex = Math.min(rampLength - 1, Math.floor(clampedAlpha * rampLength));
-      chars[i] = charRamp[rampIndex].charCodeAt(0);
+      const index = y * width + x;
+      const colorIndex = index * 4;
+      const bgR = bg2[colorIndex];
+      const bgG = bg2[colorIndex + 1];
+      const bgB = bg2[colorIndex + 2];
+      const lum = 0.299 * bgR + 0.587 * bgG + 0.114 * bgB;
+      const rampIndex = Math.min(rampLength - 1, Math.floor(lum * rampLength));
+      chars[index] = ramp[rampIndex].charCodeAt(0);
     }
   }
+  const fgMatrix = new Float32Array([
+    0,
+    0,
+    0,
+    fgColor.r,
+    0,
+    0,
+    0,
+    fgColor.g,
+    0,
+    0,
+    0,
+    fgColor.b,
+    0,
+    0,
+    0,
+    1
+  ]);
+  const bgMatrix = new Float32Array([
+    0,
+    0,
+    0,
+    bgColor.r,
+    0,
+    0,
+    0,
+    bgColor.g,
+    0,
+    0,
+    0,
+    bgColor.b,
+    0,
+    0,
+    0,
+    1
+  ]);
+  buffer.colorMatrixUniform(fgMatrix, 1, 1);
+  buffer.colorMatrixUniform(bgMatrix, 1, 2);
+}
+function applyBrightness(buffer, brightness = 0, cellMask) {
+  if (brightness === 0)
+    return;
+  const b = brightness;
+  const matrix = new Float32Array([
+    1,
+    0,
+    0,
+    b,
+    0,
+    1,
+    0,
+    b,
+    0,
+    0,
+    1,
+    b,
+    0,
+    0,
+    0,
+    1
+  ]);
+  if (!cellMask || cellMask.length === 0) {
+    buffer.colorMatrixUniform(matrix, 1, 3);
+  } else {
+    buffer.colorMatrix(matrix, cellMask, 1, 3);
+  }
+}
+function applyGain(buffer, gain = 1, cellMask) {
+  if (gain === 1)
+    return;
+  const g = Math.max(0, gain);
+  const matrix = new Float32Array([
+    g,
+    0,
+    0,
+    0,
+    0,
+    g,
+    0,
+    0,
+    0,
+    0,
+    g,
+    0,
+    0,
+    0,
+    0,
+    1
+  ]);
+  if (!cellMask || cellMask.length === 0) {
+    buffer.colorMatrixUniform(matrix, 1, 3);
+  } else {
+    buffer.colorMatrix(matrix, cellMask, 1, 3);
+  }
+}
+function createSaturationMatrix(saturation) {
+  const s = Math.max(0, saturation);
+  const sr = 0.299 * (1 - s);
+  const sg = 0.587 * (1 - s);
+  const sb = 0.114 * (1 - s);
+  const m00 = sr + s;
+  const m01 = sg;
+  const m02 = sb;
+  const m10 = sr;
+  const m11 = sg + s;
+  const m12 = sb;
+  const m20 = sr;
+  const m21 = sg;
+  const m22 = sb + s;
+  return new Float32Array([
+    m00,
+    m01,
+    m02,
+    0,
+    m10,
+    m11,
+    m12,
+    0,
+    m20,
+    m21,
+    m22,
+    0,
+    0,
+    0,
+    0,
+    1
+  ]);
+}
+function applySaturation(buffer, cellMask, strength = 1) {
+  if (strength === 1 || strength === 0) {
+    return;
+  }
+  const matrix = createSaturationMatrix(strength);
+  if (!cellMask || cellMask.length === 0) {
+    buffer.colorMatrixUniform(matrix, 1, 3);
+  } else {
+    buffer.colorMatrix(matrix, cellMask, 1, 3);
+  }
 }
 
 class BloomEffect {
@@ -1847,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,
@@ -9780,10 +10400,17 @@ function parseMarkdownIncremental(newContent, prevState, trailingUnstable = 2) {
 
 // src/renderables/Markdown.ts
 var TRAILING_MARKDOWN_BLOCK_BREAKS_RE = /(?:\r?\n){2,}$/;
+function colorsEqual(left, right) {
+  if (!left || !right)
+    return left === right;
+  return left.equals(right);
+}
 
 class MarkdownRenderable extends Renderable {
   _content = "";
   _syntaxStyle;
+  _fg;
+  _bg;
   _conceal;
   _concealCode;
   _treeSitterClient;
@@ -9810,6 +10437,8 @@ class MarkdownRenderable extends Renderable {
       flexShrink: options.flexShrink ?? 0
     });
     this._syntaxStyle = options.syntaxStyle;
+    this._fg = options.fg ? parseColor(options.fg) : undefined;
+    this._bg = options.bg ? parseColor(options.bg) : undefined;
     this._conceal = options.conceal ?? this._contentDefaultOptions.conceal;
     this._concealCode = options.concealCode ?? this._contentDefaultOptions.concealCode;
     this._content = options.content ?? this._contentDefaultOptions.content;
@@ -9840,6 +10469,26 @@ class MarkdownRenderable extends Renderable {
       this._styleDirty = true;
     }
   }
+  get fg() {
+    return this._fg;
+  }
+  set fg(value) {
+    const next = value ? parseColor(value) : undefined;
+    if (!colorsEqual(this._fg, next)) {
+      this._fg = next;
+      this._styleDirty = true;
+    }
+  }
+  get bg() {
+    return this._bg;
+  }
+  set bg(value) {
+    const next = value ? parseColor(value) : undefined;
+    if (!colorsEqual(this._bg, next)) {
+      this._bg = next;
+      this._styleDirty = true;
+    }
+  }
   get conceal() {
     return this._conceal;
   }
@@ -10034,6 +10683,8 @@ class MarkdownRenderable extends Renderable {
       content,
       filetype: "markdown",
       syntaxStyle: this._syntaxStyle,
+      fg: this._fg,
+      bg: this._bg,
       conceal: this._conceal,
       drawUnstyledText: false,
       streaming: true,
@@ -10047,8 +10698,10 @@ class MarkdownRenderable extends Renderable {
     return new CodeRenderable(this.ctx, {
       id,
       content: token.text,
-      filetype: token.lang || undefined,
+      filetype: infoStringToFiletype(token.lang ?? ""),
       syntaxStyle: this._syntaxStyle,
+      fg: this._fg,
+      bg: this._bg,
       conceal: this._concealCode,
       drawUnstyledText: !(this._streaming && this._concealCode),
       streaming: this._streaming,
@@ -10061,6 +10714,8 @@ class MarkdownRenderable extends Renderable {
     renderable.content = content;
     renderable.filetype = "markdown";
     renderable.syntaxStyle = this._syntaxStyle;
+    renderable.fg = this._fg;
+    renderable.bg = this._bg;
     renderable.conceal = this._conceal;
     renderable.drawUnstyledText = false;
     renderable.streaming = true;
@@ -10068,8 +10723,10 @@ class MarkdownRenderable extends Renderable {
   }
   applyCodeBlockRenderable(renderable, token, marginBottom) {
     renderable.content = token.text;
-    renderable.filetype = token.lang || undefined;
+    renderable.filetype = infoStringToFiletype(token.lang ?? "");
     renderable.syntaxStyle = this._syntaxStyle;
+    renderable.fg = this._fg;
+    renderable.bg = this._bg;
     renderable.conceal = this._concealCode;
     renderable.drawUnstyledText = !(this._streaming && this._concealCode);
     renderable.streaming = this._streaming;
@@ -12613,7 +13270,7 @@ class TimeToFirstDrawRenderable extends Renderable {
     return Math.max(0, Math.floor(value));
   }
 }
-export { TextBufferView, EditBuffer, EditorView, convertThemeToStyles, SyntaxStyle, applyScanlines, applyGrayscale, applySepia, applyInvert, applyNoise, applyChromaticAberration, applyAsciiArt, DistortionEffect, VignetteEffect, BrightnessEffect, BlurEffect, 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=CD08AAE46AF2DC0264756E2164756E21
-//# sourceMappingURL=index-nyw5p3ep.js.map
+//# debugId=22B8DF0D4AE1971464756E2164756E21
+//# sourceMappingURL=index-k03avn41.js.map