kailogger 1.0.0-dark.red → 1.0.2

package/dist/styles/KaiChroma.js

@@ -0,0 +1,407 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KaiChroma = void 0;
+const os_1 = __importDefault(require("os"));
+const env = process.env;
+const isTTY = process.stdout.isTTY;
+const platform = os_1.default.platform();
+const supportLevel = (() => {
+    if (env.CI && !env.FORCE_COLOR)
+        return 0;
+    if (!isTTY && !env.FORCE_COLOR)
+        return 0;
+    if (env.FORCE_COLOR === '0')
+        return 0;
+    if (env.FORCE_COLOR === '1')
+        return 1;
+    if (env.FORCE_COLOR === '2')
+        return 2;
+    if (env.FORCE_COLOR === '3')
+        return 3;
+    if (platform === 'win32') {
+        if (env.WT_SESSION || env.ConEmuANSI === 'ON')
+            return 3;
+    }
+    if (env.COLORTERM === 'truecolor' || env.COLORTERM === '24bit')
+        return 3;
+    if (env.TERM_PROGRAM === 'iTerm.app')
+        return 3;
+    if (env.TERM_PROGRAM === 'Apple_Terminal')
+        return 2;
+    if (env.TERM_PROGRAM === 'Hyper')
+        return 3;
+    if (env.TERM_PROGRAM === 'vscode')
+        return 3;
+    const term = env.TERM || '';
+    if (term.includes('truecolor') || term.includes('24bit'))
+        return 3;
+    if (term.includes('256color'))
+        return 2;
+    if (term === 'xterm' || term === 'screen' || term === 'linux')
+        return 1;
+    return isTTY ? 1 : 0;
+})();
+class KaiChroma {
+    static hexToRgb(hex) {
+        const cleanHex = hex.replace(/^#/, '');
+        const bigint = parseInt(cleanHex, 16);
+        return [(bigint >> 16) & 255, (bigint >> 8) & 255, bigint & 255];
+    }
+    static rgbToHex(r, g, b) {
+        return '#' + [r, g, b].map(x => {
+            const hex = x.toString(16);
+            return hex.length === 1 ? '0' + hex : hex;
+        }).join('');
+    }
+    static rgbToHsl(r, g, b) {
+        r /= 255;
+        g /= 255;
+        b /= 255;
+        const max = Math.max(r, g, b), min = Math.min(r, g, b);
+        let h = 0, s = 0, l = (max + min) / 2;
+        if (max !== min) {
+            const d = max - min;
+            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+            switch (max) {
+                case r:
+                    h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+                    break;
+                case g:
+                    h = ((b - r) / d + 2) / 6;
+                    break;
+                case b:
+                    h = ((r - g) / d + 4) / 6;
+                    break;
+            }
+        }
+        return { h: h * 360, s: s * 100, l: l * 100 };
+    }
+    static hslToRgb(h, s, l) {
+        h /= 360;
+        s /= 100;
+        l /= 100;
+        const hue2rgb = (p, q, t) => {
+            if (t < 0)
+                t += 1;
+            if (t > 1)
+                t -= 1;
+            if (t < 1 / 6)
+                return p + (q - p) * 6 * t;
+            if (t < 1 / 2)
+                return q;
+            if (t < 2 / 3)
+                return p + (q - p) * (2 / 3 - t) * 6;
+            return p;
+        };
+        if (s === 0) {
+            const val = Math.round(l * 255);
+            return [val, val, val];
+        }
+        const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        const p = 2 * l - q;
+        return [
+            Math.round(hue2rgb(p, q, h + 1 / 3) * 255),
+            Math.round(hue2rgb(p, q, h) * 255),
+            Math.round(hue2rgb(p, q, h - 1 / 3) * 255)
+        ];
+    }
+    static rgbToAnsi256(r, g, b) {
+        if (r === g && g === b) {
+            if (r < 8)
+                return 16;
+            if (r > 248)
+                return 231;
+            return Math.round(((r - 8) / 247) * 24) + 232;
+        }
+        return 16 + (36 * Math.round(r / 255 * 5)) + (6 * Math.round(g / 255 * 5)) + Math.round(b / 255 * 5);
+    }
+    static interpolateLinear(start, end, t) {
+        return [
+            Math.round(start[0] + (end[0] - start[0]) * t),
+            Math.round(start[1] + (end[1] - start[1]) * t),
+            Math.round(start[2] + (end[2] - start[2]) * t)
+        ];
+    }
+    static interpolateEase(start, end, t) {
+        const eased = t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+        return this.interpolateLinear(start, end, eased);
+    }
+    static interpolateBezier(start, end, t) {
+        const bezier = t * t * (3 - 2 * t);
+        return this.interpolateLinear(start, end, bezier);
+    }
+    static interpolateSmooth(start, end, t) {
+        const smooth = t * t * t * (t * (t * 6 - 15) + 10);
+        return this.interpolateLinear(start, end, smooth);
+    }
+    static hex(hex, text) {
+        if (supportLevel === 0)
+            return text;
+        const cacheKey = `hex:${hex}:${supportLevel}`;
+        const [r, g, b] = this.hexToRgb(hex);
+        if (supportLevel === 3) {
+            return `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`;
+        }
+        else if (supportLevel === 2) {
+            return `\x1b[38;5;${this.rgbToAnsi256(r, g, b)}m${text}\x1b[39m`;
+        }
+        return text;
+    }
+    static rgb(r, g, b, text) {
+        if (supportLevel === 0)
+            return text;
+        if (supportLevel === 3) {
+            return `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`;
+        }
+        else if (supportLevel === 2) {
+            return `\x1b[38;5;${this.rgbToAnsi256(r, g, b)}m${text}\x1b[39m`;
+        }
+        return text;
+    }
+    static hsl(h, s, l, text) {
+        const [r, g, b] = this.hslToRgb(h, s, l);
+        return this.rgb(r, g, b, text);
+    }
+    static bgHex(hex, text) {
+        if (supportLevel === 0)
+            return text;
+        const [r, g, b] = this.hexToRgb(hex);
+        if (supportLevel === 3) {
+            return `\x1b[48;2;${r};${g};${b}m${text}\x1b[49m`;
+        }
+        else if (supportLevel === 2) {
+            return `\x1b[48;5;${this.rgbToAnsi256(r, g, b)}m${text}\x1b[49m`;
+        }
+        return text;
+    }
+    static bgRgb(r, g, b, text) {
+        if (supportLevel === 0)
+            return text;
+        if (supportLevel === 3) {
+            return `\x1b[48;2;${r};${g};${b}m${text}\x1b[49m`;
+        }
+        else if (supportLevel === 2) {
+            return `\x1b[48;5;${this.rgbToAnsi256(r, g, b)}m${text}\x1b[49m`;
+        }
+        return text;
+    }
+    static bold(text) { return `\x1b[1m${text}\x1b[22m`; }
+    static dim(text) { return `\x1b[2m${text}\x1b[22m`; }
+    static italic(text) { return `\x1b[3m${text}\x1b[23m`; }
+    static underline(text) { return `\x1b[4m${text}\x1b[24m`; }
+    static inverse(text) { return `\x1b[7m${text}\x1b[27m`; }
+    static hidden(text) { return `\x1b[8m${text}\x1b[28m`; }
+    static strikethrough(text) { return `\x1b[9m${text}\x1b[29m`; }
+    static blink(text) { return `\x1b[5m${text}\x1b[25m`; }
+    static style(text, options) {
+        let result = text;
+        if (options.bold)
+            result = this.bold(result);
+        if (options.dim)
+            result = this.dim(result);
+        if (options.italic)
+            result = this.italic(result);
+        if (options.underline)
+            result = this.underline(result);
+        if (options.inverse)
+            result = this.inverse(result);
+        if (options.strikethrough)
+            result = this.strikethrough(result);
+        if (options.blink)
+            result = this.blink(result);
+        if (options.hidden)
+            result = this.hidden(result);
+        return result;
+    }
+    static gradient(colors, text, options = {}) {
+        if (supportLevel === 0)
+            return text;
+        if (colors.length < 2)
+            return this.hex(colors[0] || '#ffffff', text);
+        const interpolation = options.interpolation || 'linear';
+        const rgbColors = colors.map(c => this.hexToRgb(c));
+        const chars = [...text];
+        const steps = chars.length;
+        let output = '';
+        const interpolate = (start, end, t) => {
+            switch (interpolation) {
+                case 'ease': return this.interpolateEase(start, end, t);
+                case 'bezier': return this.interpolateBezier(start, end, t);
+                case 'smooth': return this.interpolateSmooth(start, end, t);
+                default: return this.interpolateLinear(start, end, t);
+            }
+        };
+        chars.forEach((char, i) => {
+            const t = steps <= 1 ? 0 : i / (steps - 1);
+            const segmentLength = 1 / (rgbColors.length - 1);
+            const segmentIndex = Math.min(Math.floor(t / segmentLength), rgbColors.length - 2);
+            const segmentT = (t - (segmentIndex * segmentLength)) / segmentLength;
+            const [r, g, b] = interpolate(rgbColors[segmentIndex], rgbColors[segmentIndex + 1], segmentT);
+            if (supportLevel === 3) {
+                output += `\x1b[38;2;${r};${g};${b}m${char}`;
+            }
+            else if (supportLevel === 2) {
+                output += `\x1b[38;5;${this.rgbToAnsi256(r, g, b)}m${char}`;
+            }
+            else {
+                output += char;
+            }
+        });
+        return output + '\x1b[39m';
+    }
+    static rainbowGradient(text) {
+        return this.gradient(['#FF0000', '#FF7F00', '#FFFF00', '#00FF00', '#0000FF', '#4B0082', '#9400D3'], text, { interpolation: 'smooth' });
+    }
+    static sunsetGradient(text) {
+        return this.gradient(['#FF512F', '#F09819', '#FFD89B'], text, { interpolation: 'ease' });
+    }
+    static oceanGradient(text) {
+        return this.gradient(['#667eea', '#764ba2', '#f093fb'], text, { interpolation: 'bezier' });
+    }
+    static fireGradient(text) {
+        return this.gradient(['#ff0000', '#ff4500', '#ffa500', '#ffff00'], text, { interpolation: 'smooth' });
+    }
+    static matrixGradient(text) {
+        return this.gradient(['#00ff00', '#00cc00', '#009900'], text, { interpolation: 'linear' });
+    }
+    static lighten(hex, amount) {
+        const [r, g, b] = this.hexToRgb(hex);
+        const hsl = this.rgbToHsl(r, g, b);
+        hsl.l = Math.min(100, hsl.l + amount);
+        const [nr, ng, nb] = this.hslToRgb(hsl.h, hsl.s, hsl.l);
+        return this.rgbToHex(nr, ng, nb);
+    }
+    static darken(hex, amount) {
+        return this.lighten(hex, -amount);
+    }
+    static saturate(hex, amount) {
+        const [r, g, b] = this.hexToRgb(hex);
+        const hsl = this.rgbToHsl(r, g, b);
+        hsl.s = Math.min(100, hsl.s + amount);
+        const [nr, ng, nb] = this.hslToRgb(hsl.h, hsl.s, hsl.l);
+        return this.rgbToHex(nr, ng, nb);
+    }
+    static desaturate(hex, amount) {
+        return this.saturate(hex, -amount);
+    }
+    static rotate(hex, degrees) {
+        const [r, g, b] = this.hexToRgb(hex);
+        const hsl = this.rgbToHsl(r, g, b);
+        hsl.h = (hsl.h + degrees) % 360;
+        if (hsl.h < 0)
+            hsl.h += 360;
+        const [nr, ng, nb] = this.hslToRgb(hsl.h, hsl.s, hsl.l);
+        return this.rgbToHex(nr, ng, nb);
+    }
+    static mix(hex1, hex2, weight = 0.5) {
+        const [r1, g1, b1] = this.hexToRgb(hex1);
+        const [r2, g2, b2] = this.hexToRgb(hex2);
+        const [r, g, b] = this.interpolateLinear([r1, g1, b1], [r2, g2, b2], weight);
+        return this.rgbToHex(r, g, b);
+    }
+    static analogous(hex, count = 3) {
+        const palette = [hex];
+        const step = 30;
+        for (let i = 1; i < count; i++) {
+            palette.push(this.rotate(hex, step * i));
+        }
+        return palette;
+    }
+    static complementary(hex) {
+        return [hex, this.rotate(hex, 180)];
+    }
+    static triadic(hex) {
+        return [hex, this.rotate(hex, 120), this.rotate(hex, 240)];
+    }
+    static tetradic(hex) {
+        return [hex, this.rotate(hex, 90), this.rotate(hex, 180), this.rotate(hex, 270)];
+    }
+    static monochromatic(hex, count = 5) {
+        const palette = [];
+        const step = 100 / (count - 1);
+        for (let i = 0; i < count; i++) {
+            palette.push(this.lighten(hex, -50 + step * i));
+        }
+        return palette;
+    }
+    static strip(text) {
+        return text.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+    }
+    static getSupport() {
+        return supportLevel;
+    }
+    static getSupportName() {
+        const names = ['none', 'basic', '256', 'truecolor'];
+        return names[supportLevel];
+    }
+    static isSupported() {
+        return supportLevel > 0;
+    }
+    static textLength(text) {
+        return this.strip(text).length;
+    }
+    static box(text, color = '#ffffff', padding = 1) {
+        const lines = text.split('\n');
+        const maxLen = Math.max(...lines.map(l => this.textLength(l)));
+        const pad = ' '.repeat(padding);
+        const width = maxLen + padding * 2;
+        const top = this.hex(color, '┌' + '─'.repeat(width) + '┐');
+        const bottom = this.hex(color, '└' + '─'.repeat(width) + '┘');
+        const content = lines.map(line => {
+            const spaces = ' '.repeat(maxLen - this.textLength(line));
+            return this.hex(color, '│') + pad + line + spaces + pad + this.hex(color, '│');
+        }).join('\n');
+        return `${top}\n${content}\n${bottom}`;
+    }
+    static wave(text, colors) {
+        if (supportLevel === 0)
+            return text;
+        const chars = [...text];
+        const rgbColors = colors.map(c => this.hexToRgb(c));
+        let output = '';
+        chars.forEach((char, i) => {
+            const colorIndex = Math.floor((Math.sin(i * 0.5) + 1) * (rgbColors.length - 1) / 2);
+            const [r, g, b] = rgbColors[colorIndex];
+            if (supportLevel === 3) {
+                output += `\x1b[38;2;${r};${g};${b}m${char}`;
+            }
+            else if (supportLevel === 2) {
+                output += `\x1b[38;5;${this.rgbToAnsi256(r, g, b)}m${char}`;
+            }
+            else {
+                output += char;
+            }
+        });
+        return output + '\x1b[39m';
+    }
+    static pulse(text, color, frames = 10) {
+        const result = [];
+        const [r, g, b] = this.hexToRgb(color);
+        for (let i = 0; i < frames; i++) {
+            const brightness = (Math.sin((i / frames) * Math.PI * 2) + 1) / 2;
+            const adjustedR = Math.round(r * brightness);
+            const adjustedG = Math.round(g * brightness);
+            const adjustedB = Math.round(b * brightness);
+            result.push(this.rgb(adjustedR, adjustedG, adjustedB, text));
+        }
+        return result;
+    }
+    static clearCacheIfNeeded() {
+        if (this.cache.size > this.MAX_CACHE_SIZE) {
+            const entriesToDelete = this.cache.size - this.MAX_CACHE_SIZE / 2;
+            const iterator = this.cache.keys();
+            for (let i = 0; i < entriesToDelete; i++) {
+                const key = iterator.next().value;
+                if (key)
+                    this.cache.delete(key);
+            }
+        }
+    }
+}
+exports.KaiChroma = KaiChroma;
+KaiChroma.cache = new Map();
+KaiChroma.MAX_CACHE_SIZE = 1000;
+exports.default = KaiChroma;

package/dist/styles/gradients.d.ts

@@ -16,12 +16,40 @@ export declare class GradientEngine {
         warning: string[];
         info: string[];
         debug: string[];
+        light: string;
+        dim: string;
+    } | {
+        success: string[];
+        error: string[];
+        warning: string[];
+        info: string[];
+        debug: string[];
+        light: string;
+        dim: string;
+    } | {
+        success: string[];
+        error: string[];
+        warning: string[];
+        info: string[];
+        debug: string[];
+        light: string;
+        dim: string;
+    } | {
+        success: string[];
+        error: string[];
+        warning: string[];
+        info: string[];
+        debug: string[];
+        light: string;
+        dim: string;
     } | {
         success: string[];
         error: string[];
         warning: string[];
         info: string[];
         debug: string[];
+        light: string;
+        dim: string;
     };
     apply(text: string, colors: string[]): string;
     multiline(text: string, colors: string[]): string;

package/dist/styles/palettes.d.ts

@@ -1,26 +1,21 @@
-export declare const palettes: {
-    zen: {
-        success: string[];
-        error: string[];
-        warning: string[];
-        info: string[];
-        debug: string[];
-        light: string;
-        dim: string;
-    };
-    neon: {
-        success: string[];
-        error: string[];
-        warning: string[];
-        info: string[];
-        debug: string[];
-    };
-    pastel: {
-        success: string[];
-        error: string[];
-        warning: string[];
-        info: string[];
-        debug: string[];
-    };
-};
-export type ThemeName = keyof typeof palettes;
+export type ThemeName = 'zen' | 'neon' | 'pastel' | 'hacker' | 'sunset' | 'ocean' | 'cyberpunk' | 'dracula' | 'monokai' | 'vaporwave' | 'midnight' | 'forest' | 'volcano' | 'gold';
+export interface Theme {
+    success: string[];
+    error: string[];
+    warning: string[];
+    info: string[];
+    debug: string[];
+    text: string;
+    dim: string;
+    accent: string;
+    bg?: string;
+}
+export declare const palettes: Record<ThemeName, Theme>;
+export declare class PaletteEngine {
+    private currentTheme;
+    private theme;
+    setTheme(name: ThemeName): void;
+    get colors(): Theme;
+    apply(text: string, colors: string[]): string;
+}
+export declare const paint: PaletteEngine;

package/dist/styles/palettes.js

@@ -1,28 +1,182 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.palettes = void 0;
+exports.paint = exports.PaletteEngine = exports.palettes = void 0;
+const KaiChroma_1 = require("./KaiChroma");
 exports.palettes = {
+    // 1. Zen (Minimalist, calming)
     zen: {
         success: ['#00b09b', '#96c93d'],
         error: ['#ff416c', '#ff4b2b'],
         warning: ['#f7971e', '#ffd200'],
         info: ['#2193b0', '#6dd5ed'],
         debug: ['#8e2de2', '#4a00e0'],
-        light: '#ffffff',
-        dim: '#888888'
+        text: '#ffffff',
+        dim: '#888888',
+        accent: '#00b09b'
     },
+    // 2. Neon (Bright, cyber)
     neon: {
-        success: ['#39FF14', '#00FF00'],
-        error: ['#FF00FF', '#FF0099'],
-        warning: ['#FFFF00', '#FFD700'],
-        info: ['#00FFFF', '#00BFFF'],
-        debug: ['#9D00FF', '#7F00FF']
+        success: ['#39ff14', '#00ffef'],
+        error: ['#ff0055', '#ff0099'],
+        warning: ['#ffff00', '#ffae00'],
+        info: ['#00ffff', '#0099ff'],
+        debug: ['#b300ff', '#8800ff'],
+        text: '#f0f0f0',
+        dim: '#666666',
+        accent: '#39ff14'
     },
+    // 3. Cyberpunk 2077
+    cyberpunk: {
+        success: ['#00ff9f', '#00b8ff'], // Cyan to Blue
+        error: ['#ff003c', '#ff3cac'], // Cyber Red
+        warning: ['#fcee0a', '#ffae00'], // Cyber Yellow
+        info: ['#0abdc6', '#ea00d9'], // Blue to Pink
+        debug: ['#711c91', '#ea00d9'], // Purple
+        text: '#fcee0a', // Yellow text
+        dim: '#5e4e69',
+        accent: '#0abdc6'
+    },
+    // 4. Dracula (Dark mode favorite)
+    dracula: {
+        success: ['#50fa7b', '#8be9fd'],
+        error: ['#ff5555', '#ffb86c'],
+        warning: ['#ffb86c', '#f1fa8c'],
+        info: ['#bd93f9', '#ff79c6'],
+        debug: ['#6272a4', '#8be9fd'],
+        text: '#f8f8f2',
+        dim: '#6272a4',
+        accent: '#bd93f9'
+    },
+    // 5. Monokai
+    monokai: {
+        success: ['#a6e22e', '#a6e22e'],
+        error: ['#f92672', '#f92672'],
+        warning: ['#fd971f', '#e6db74'],
+        info: ['#66d9ef', '#ae81ff'],
+        debug: ['#ae81ff', '#fd971f'],
+        text: '#f8f8f2',
+        dim: '#75715e',
+        accent: '#a6e22e'
+    },
+    // 6. Vaporwave
+    vaporwave: {
+        success: ['#00f0ff', '#ff00aa'],
+        error: ['#ff2a00', '#ff0066'],
+        warning: ['#ffcc00', '#ff9900'],
+        info: ['#ff77ff', '#9933ff'],
+        debug: ['#9900ff', '#5500aa'],
+        text: '#ff99ff',
+        dim: '#554477',
+        accent: '#00f0ff'
+    },
+    // 7. Midnight (Deep blues)
+    midnight: {
+        success: ['#34e89e', '#0f3443'],
+        error: ['#cb2d3e', '#ef473a'],
+        warning: ['#ffc371', '#ff5f6d'],
+        info: ['#56ccf2', '#2f80ed'],
+        debug: ['#642b73', '#c6426e'],
+        text: '#d1d1d1',
+        dim: '#4b5563',
+        accent: '#56ccf2'
+    },
+    // 8. Sunset (Warm)
+    sunset: {
+        success: ['#11998e', '#38ef7d'],
+        error: ['#ee0979', '#ff6a00'],
+        warning: ['#ff9966', '#ff5e62'],
+        info: ['#00c6ff', '#0072ff'],
+        debug: ['#8360c3', '#2ebf91'],
+        text: '#ffedd5',
+        dim: '#7c2d12',
+        accent: '#ff9966'
+    },
+    // 9. Ocean (Blues/Greens)
+    ocean: {
+        success: ['#4cb8c4', '#3cd3ad'],
+        error: ['#ff416c', '#ff4b2b'],
+        warning: ['#f09819', '#edde5d'],
+        info: ['#2b5876', '#4e4376'],
+        debug: ['#1c92d2', '#f2fcfe'],
+        text: '#e0f2fe',
+        dim: '#1e3a8a',
+        accent: '#4cb8c4'
+    },
+    // 10. Pastel (Soft)
     pastel: {
-        success: ['#77DD77', '#55BB55'],
-        error: ['#FF6961', '#FF4444'],
-        warning: ['#FFB347', '#FF9933'],
-        info: ['#AEC6CF', '#88aabb'],
-        debug: ['#B39EB5', '#9988aa']
+        success: ['#B2F7EF', '#7BDFF2'],
+        error: ['#FFB7B2', '#FF9AA2'],
+        warning: ['#FFE29A', '#FFDAC1'],
+        info: ['#A0E7E5', '#B4F8C8'],
+        debug: ['#FBE7C6', '#C3B1E1'],
+        text: '#ffffff',
+        dim: '#a0a0a0',
+        accent: '#B2F7EF'
+    },
+    // 11. Hacker
+    hacker: {
+        success: ['#00ff00', '#003300'],
+        error: ['#ff0000', '#330000'],
+        warning: ['#ffff00', '#333300'],
+        info: ['#0000ff', '#000033'],
+        debug: ['#ff00ff', '#330033'],
+        text: '#00ff00',
+        dim: '#004400',
+        accent: '#00ff00'
+    },
+    // 12. Volcano
+    volcano: {
+        success: ['#FF8008', '#FFC837'],
+        error: ['#FF0000', '#950000'],
+        warning: ['#FF4B1F', '#1FDDFF'],
+        info: ['#ED4264', '#FFEDBC'],
+        debug: ['#2C3E50', '#FD746C'],
+        text: '#FFD700',
+        dim: '#500000',
+        accent: '#FF4B1F'
+    },
+    // 13. Forest
+    forest: {
+        success: ['#134E5E', '#71B280'],
+        error: ['#603813', '#b29f94'],
+        warning: ['#eacda3', '#d6ae7b'],
+        info: ['#5D4157', '#A8CABA'],
+        debug: ['#4DA0B0', '#D39D38'],
+        text: '#D4FFD6',
+        dim: '#2b3d2b',
+        accent: '#71B280'
+    },
+    // 14. Gold (Luxury)
+    gold: {
+        success: ['#F2994A', '#F2C94C'],
+        error: ['#8e2de2', '#4a00e0'],
+        warning: ['#CAC531', '#F3F9A7'],
+        info: ['#7F7FD5', '#86A8E7'],
+        debug: ['#E0EAFC', '#CFDEF3'],
+        text: '#FFD700',
+        dim: '#706015',
+        accent: '#F2C94C'
     }
 };
+class PaletteEngine {
+    constructor() {
+        this.currentTheme = 'zen';
+        this.theme = exports.palettes.zen;
+    }
+    setTheme(name) {
+        if (exports.palettes[name]) {
+            this.currentTheme = name;
+            this.theme = exports.palettes[name];
+        }
+    }
+    get colors() {
+        return this.theme;
+    }
+    apply(text, colors) {
+        if (colors.length === 1)
+            return KaiChroma_1.KaiChroma.hex(colors[0], text);
+        return KaiChroma_1.KaiChroma.gradient(colors, text);
+    }
+}
+exports.PaletteEngine = PaletteEngine;
+exports.paint = new PaletteEngine();