chalk-ts 1.0.0

package/dist/index.js

@@ -0,0 +1,886 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * ANSI color and style codes
+ */
+const ANSI_CODES = {
+    // Reset
+    reset: '\u001B[0m',
+    // Text styles
+    bold: '\u001B[1m',
+    dim: '\u001B[2m',
+    italic: '\u001B[3m',
+    underline: '\u001B[4m',
+    blink: '\u001B[5m',
+    inverse: '\u001B[7m',
+    hidden: '\u001B[8m',
+    strikethrough: '\u001B[9m',
+    // Foreground colors
+    black: '\u001B[30m',
+    red: '\u001B[31m',
+    green: '\u001B[32m',
+    yellow: '\u001B[33m',
+    blue: '\u001B[34m',
+    magenta: '\u001B[35m',
+    cyan: '\u001B[36m',
+    white: '\u001B[37m',
+    gray: '\u001B[90m',
+    grey: '\u001B[90m',
+    // Bright foreground colors
+    redBright: '\u001B[91m',
+    greenBright: '\u001B[92m',
+    yellowBright: '\u001B[93m',
+    blueBright: '\u001B[94m',
+    magentaBright: '\u001B[95m',
+    cyanBright: '\u001B[96m',
+    whiteBright: '\u001B[97m',
+    // Background colors
+    bgBlack: '\u001B[40m',
+    bgRed: '\u001B[41m',
+    bgGreen: '\u001B[42m',
+    bgYellow: '\u001B[43m',
+    bgBlue: '\u001B[44m',
+    bgMagenta: '\u001B[45m',
+    bgCyan: '\u001B[46m',
+    bgWhite: '\u001B[47m',
+    bgGray: '\u001B[100m',
+    bgGrey: '\u001B[100m',
+    // Bright background colors
+    bgRedBright: '\u001B[101m',
+    bgGreenBright: '\u001B[102m',
+    bgYellowBright: '\u001B[103m',
+    bgBlueBright: '\u001B[104m',
+    bgMagentaBright: '\u001B[105m',
+    bgCyanBright: '\u001B[106m',
+    bgWhiteBright: '\u001B[107m',
+};
+/**
+ * Check if colors are supported in the current environment
+ */
+function supportsColor() {
+    if (typeof process === 'undefined')
+        return false;
+    const { env, platform, stdout } = process;
+    // Force color support
+    if (env.FORCE_COLOR === '1' || env.FORCE_COLOR === 'true')
+        return true;
+    if (env.FORCE_COLOR === '0' || env.FORCE_COLOR === 'false')
+        return false;
+    // No color support
+    if (env.NO_COLOR || env.NODE_DISABLE_COLORS)
+        return false;
+    // CI environments
+    if (env.CI && !env.GITHUB_ACTIONS)
+        return false;
+    // Terminal capabilities
+    if (platform === 'win32') {
+        return !!(env.TERM && env.TERM !== 'dumb');
+    }
+    if (!stdout || !stdout.isTTY)
+        return false;
+    const term = env.TERM?.toLowerCase();
+    if (term === 'dumb')
+        return false;
+    return !!(term &&
+        (term.includes('color') ||
+            term.includes('256') ||
+            term.includes('ansi') ||
+            term === 'xterm' ||
+            term === 'screen' ||
+            term === 'vt100' ||
+            env.COLORTERM));
+}
+/**
+ * Get color level support (0: no color, 1: basic, 2: 256 colors, 3: 16m colors)
+ */
+function getColorLevel() {
+    if (!supportsColor())
+        return 0;
+    const { env } = process;
+    if (env.COLORTERM === 'truecolor' || env.TERM === 'xterm-256color')
+        return 3;
+    if (env.TERM?.includes('256'))
+        return 2;
+    return 1;
+}
+
+/**
+ * Color utilities for RGB, HSL, and HEX conversions
+ */
+/**
+ * Convert HEX color to RGB
+ */
+function hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result && result.length >= 4
+        ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16),
+        }
+        : null;
+}
+/**
+ * Convert RGB to HEX
+ */
+function rgbToHex(r, g, b) {
+    const toHex = (c) => {
+        const hex = Math.round(Math.max(0, Math.min(255, c))).toString(16);
+        return hex.length === 1 ? "0" + hex : hex;
+    };
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+/**
+ * Convert HSL to RGB
+ */
+function hslToRgb(h, s, l) {
+    h = h / 360;
+    s = s / 100;
+    l = 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;
+    };
+    let r, g, b;
+    if (s === 0) {
+        r = g = b = l;
+    }
+    else {
+        const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        const p = 2 * l - q;
+        r = hue2rgb(p, q, h + 1 / 3);
+        g = hue2rgb(p, q, h);
+        b = hue2rgb(p, q, h - 1 / 3);
+    }
+    return {
+        r: Math.round(r * 255),
+        g: Math.round(g * 255),
+        b: Math.round(b * 255),
+    };
+}
+/**
+ * Convert RGB to HSL
+ */
+function rgbToHsl(r, g, b) {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    let h = 0;
+    let s = 0;
+    const l = (max + min) / 2;
+    if (max === min) {
+        h = s = 0; // achromatic
+    }
+    else {
+        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);
+                break;
+            case g:
+                h = (b - r) / d + 2;
+                break;
+            case b:
+                h = (r - g) / d + 4;
+                break;
+        }
+        h /= 6;
+    }
+    return {
+        h: Math.round(h * 360),
+        s: Math.round(s * 100),
+        l: Math.round(l * 100),
+    };
+}
+/**
+ * Generate RGB ANSI escape code
+ */
+function rgb(r, g, b, background = false) {
+    const prefix = background ? "48" : "38";
+    return `\u001B[${prefix};2;${Math.round(r)};${Math.round(g)};${Math.round(b)}m`;
+}
+/**
+ * Generate HEX ANSI escape code
+ */
+function hex(color, background = false) {
+    const rgbColor = hexToRgb(color);
+    if (!rgbColor)
+        throw new Error(`Invalid hex color: ${color}`);
+    return rgb(rgbColor.r, rgbColor.g, rgbColor.b, background);
+}
+/**
+ * Generate HSL ANSI escape code
+ */
+function hsl(h, s, l, background = false) {
+    const rgbColor = hslToRgb(h, s, l);
+    return rgb(rgbColor.r, rgbColor.g, rgbColor.b, background);
+}
+/**
+ * Predefined color palette
+ */
+const COLORS = {
+    // Standard colors
+    black: { r: 0, g: 0, b: 0 },
+    red: { r: 255, g: 0, b: 0 },
+    green: { r: 0, g: 255, b: 0 },
+    yellow: { r: 255, g: 255, b: 0 },
+    blue: { r: 0, g: 0, b: 255 },
+    magenta: { r: 255, g: 0, b: 255 },
+    cyan: { r: 0, g: 255, b: 255 },
+    white: { r: 255, g: 255, b: 255 },
+    // Extended colors
+    orange: { r: 255, g: 165, b: 0 },
+    purple: { r: 128, g: 0, b: 128 },
+    pink: { r: 255, g: 192, b: 203 },
+    brown: { r: 165, g: 42, b: 42 },
+    lime: { r: 0, g: 255, b: 0 },
+    indigo: { r: 75, g: 0, b: 130 },
+    violet: { r: 238, g: 130, b: 238 },
+    turquoise: { r: 64, g: 224, b: 208 },
+    gold: { r: 255, g: 215, b: 0 },
+    silver: { r: 192, g: 192, b: 192 },
+};
+
+/**
+ * Main ChalkTS class with all styling capabilities
+ */
+class ChalkTS {
+    colorEnabled;
+    constructor(enabled) {
+        this.colorEnabled = enabled ?? supportsColor();
+    }
+    /**
+     * Apply ANSI codes to text
+     */
+    apply(codes, text) {
+        if (!this.colorEnabled)
+            return String(text);
+        if (text == null)
+            return String(text);
+        if (text === "")
+            return text;
+        return codes.join("") + text + ANSI_CODES.reset;
+    }
+    /**
+     * Create a new instance with color support disabled
+     */
+    get disabled() {
+        return new ChalkTS(false);
+    }
+    /**
+     * Create a new instance with color support enabled
+     */
+    get enabled() {
+        return new ChalkTS(true);
+    }
+    // Text styles
+    get bold() {
+        return this.createStyler([ANSI_CODES.bold]);
+    }
+    get dim() {
+        return this.createStyler([ANSI_CODES.dim]);
+    }
+    get italic() {
+        return this.createStyler([ANSI_CODES.italic]);
+    }
+    get underline() {
+        return this.createStyler([ANSI_CODES.underline]);
+    }
+    get blink() {
+        return this.createStyler([ANSI_CODES.blink]);
+    }
+    get inverse() {
+        return this.createStyler([ANSI_CODES.inverse]);
+    }
+    get hidden() {
+        return this.createStyler([ANSI_CODES.hidden]);
+    }
+    get strikethrough() {
+        return this.createStyler([ANSI_CODES.strikethrough]);
+    }
+    // Foreground colors
+    get black() {
+        return this.createStyler([ANSI_CODES.black]);
+    }
+    get red() {
+        return this.createStyler([ANSI_CODES.red]);
+    }
+    get green() {
+        return this.createStyler([ANSI_CODES.green]);
+    }
+    get yellow() {
+        return this.createStyler([ANSI_CODES.yellow]);
+    }
+    get blue() {
+        return this.createStyler([ANSI_CODES.blue]);
+    }
+    get magenta() {
+        return this.createStyler([ANSI_CODES.magenta]);
+    }
+    get cyan() {
+        return this.createStyler([ANSI_CODES.cyan]);
+    }
+    get white() {
+        return this.createStyler([ANSI_CODES.white]);
+    }
+    get gray() {
+        return this.createStyler([ANSI_CODES.gray]);
+    }
+    get grey() {
+        return this.createStyler([ANSI_CODES.grey]);
+    }
+    // Bright foreground colors
+    get redBright() {
+        return this.createStyler([ANSI_CODES.redBright]);
+    }
+    get greenBright() {
+        return this.createStyler([ANSI_CODES.greenBright]);
+    }
+    get yellowBright() {
+        return this.createStyler([ANSI_CODES.yellowBright]);
+    }
+    get blueBright() {
+        return this.createStyler([ANSI_CODES.blueBright]);
+    }
+    get magentaBright() {
+        return this.createStyler([ANSI_CODES.magentaBright]);
+    }
+    get cyanBright() {
+        return this.createStyler([ANSI_CODES.cyanBright]);
+    }
+    get whiteBright() {
+        return this.createStyler([ANSI_CODES.whiteBright]);
+    }
+    // Background colors
+    get bgBlack() {
+        return this.createStyler([ANSI_CODES.bgBlack]);
+    }
+    get bgRed() {
+        return this.createStyler([ANSI_CODES.bgRed]);
+    }
+    get bgGreen() {
+        return this.createStyler([ANSI_CODES.bgGreen]);
+    }
+    get bgYellow() {
+        return this.createStyler([ANSI_CODES.bgYellow]);
+    }
+    get bgBlue() {
+        return this.createStyler([ANSI_CODES.bgBlue]);
+    }
+    get bgMagenta() {
+        return this.createStyler([ANSI_CODES.bgMagenta]);
+    }
+    get bgCyan() {
+        return this.createStyler([ANSI_CODES.bgCyan]);
+    }
+    get bgWhite() {
+        return this.createStyler([ANSI_CODES.bgWhite]);
+    }
+    get bgGray() {
+        return this.createStyler([ANSI_CODES.bgGray]);
+    }
+    get bgGrey() {
+        return this.createStyler([ANSI_CODES.bgGrey]);
+    }
+    // Bright background colors
+    get bgRedBright() {
+        return this.createStyler([ANSI_CODES.bgRedBright]);
+    }
+    get bgGreenBright() {
+        return this.createStyler([ANSI_CODES.bgGreenBright]);
+    }
+    get bgYellowBright() {
+        return this.createStyler([ANSI_CODES.bgYellowBright]);
+    }
+    get bgBlueBright() {
+        return this.createStyler([ANSI_CODES.bgBlueBright]);
+    }
+    get bgMagentaBright() {
+        return this.createStyler([ANSI_CODES.bgMagentaBright]);
+    }
+    get bgCyanBright() {
+        return this.createStyler([ANSI_CODES.bgCyanBright]);
+    }
+    get bgWhiteBright() {
+        return this.createStyler([ANSI_CODES.bgWhiteBright]);
+    }
+    // Advanced color methods
+    rgb(r, g, b) {
+        return this.createStyler([rgb(r, g, b)]);
+    }
+    bgRgb(r, g, b) {
+        return this.createStyler([rgb(r, g, b, true)]);
+    }
+    hex(color) {
+        return this.createStyler([hex(color)]);
+    }
+    bgHex(color) {
+        return this.createStyler([hex(color, true)]);
+    }
+    hsl(h, s, l) {
+        return this.createStyler([hsl(h, s, l)]);
+    }
+    bgHsl(h, s, l) {
+        return this.createStyler([hsl(h, s, l, true)]);
+    }
+    // Extended color palette
+    get orange() {
+        const color = COLORS.orange;
+        return this.createStyler([rgb(color.r, color.g, color.b)]);
+    }
+    get purple() {
+        const color = COLORS.purple;
+        return this.createStyler([rgb(color.r, color.g, color.b)]);
+    }
+    get pink() {
+        const color = COLORS.pink;
+        return this.createStyler([rgb(color.r, color.g, color.b)]);
+    }
+    get brown() {
+        const color = COLORS.brown;
+        return this.createStyler([rgb(color.r, color.g, color.b)]);
+    }
+    get lime() {
+        const color = COLORS.lime;
+        return this.createStyler([rgb(color.r, color.g, color.b)]);
+    }
+    get indigo() {
+        const color = COLORS.indigo;
+        return this.createStyler([rgb(color.r, color.g, color.b)]);
+    }
+    get violet() {
+        const color = COLORS.violet;
+        return this.createStyler([rgb(color.r, color.g, color.b)]);
+    }
+    get turquoise() {
+        return this.createStyler([rgb(64, 224, 208)]);
+    }
+    get gold() {
+        return this.createStyler([rgb(255, 215, 0)]);
+    }
+    get silver() {
+        return this.createStyler([rgb(192, 192, 192)]);
+    }
+    // Utility methods
+    strip(text) {
+        // Remove all ANSI escape sequences
+        return text.replace(/\u001B\[[0-9;]*m/g, "");
+    }
+    length(text) {
+        return this.strip(text).length;
+    }
+    // Template literal support
+    template(template, ...substitutions) {
+        let result = "";
+        for (let i = 0; i < template.length; i++) {
+            result += template[i];
+            if (i < substitutions.length) {
+                result += String(substitutions[i]);
+            }
+        }
+        return result;
+    }
+    /**
+     * Create a styled function that can be chained
+     */
+    createStyler(codes) {
+        const styler = (text) => this.apply(codes, text);
+        // Create a new ChalkTS instance with accumulated codes
+        const newChalk = new ChalkTS(this.colorEnabled);
+        // Copy all properties and methods to the styler function
+        Object.setPrototypeOf(styler, newChalk);
+        Object.assign(styler, newChalk);
+        // Override the createStyler method to accumulate codes
+        styler.createStyler = (newCodes) => {
+            return this.createStyler([...codes, ...newCodes]);
+        };
+        return styler;
+    }
+}
+/**
+ * Default instance
+ */
+const chalkTs = new ChalkTS();
+/**
+ * Export individual color functions for convenience
+ */
+const { bold, dim, italic, underline, blink, inverse, hidden, strikethrough, black, red, green, yellow, blue, magenta, cyan, white, gray, grey, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bgGray, bgGrey, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright, orange, purple, pink, brown, lime, indigo, violet, turquoise, gold, silver, } = chalkTs;
+
+/**
+ * Advanced styling utilities and effects
+ */
+/**
+ * Create a gradient effect between two colors
+ */
+function gradient(text, startColor, endColor) {
+    if (text.length === 0)
+        return text;
+    const chalk = new ChalkTS();
+    // Parse hex colors
+    const parseHex = (hex) => {
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+        return result && result.length >= 4
+            ? {
+                r: parseInt(result[1], 16),
+                g: parseInt(result[2], 16),
+                b: parseInt(result[3], 16),
+            }
+            : null;
+    };
+    const start = parseHex(startColor);
+    const end = parseHex(endColor);
+    if (!start || !end) {
+        throw new Error("Invalid hex colors provided");
+    }
+    let result = "";
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (char) {
+            const ratio = i / (text.length - 1);
+            const r = Math.round(start.r + (end.r - start.r) * ratio);
+            const g = Math.round(start.g + (end.g - start.g) * ratio);
+            const b = Math.round(start.b + (end.b - start.b) * ratio);
+            result += chalk.rgb(r, g, b)(char);
+        }
+    }
+    return result;
+}
+/**
+ * Create a rainbow effect
+ */
+function rainbow(text) {
+    if (text.length === 0)
+        return text;
+    const chalk = new ChalkTS();
+    const colors = [
+        [255, 0, 0], // Red
+        [255, 127, 0], // Orange
+        [255, 255, 0], // Yellow
+        [0, 255, 0], // Green
+        [0, 0, 255], // Blue
+        [75, 0, 130], // Indigo
+        [148, 0, 211], // Violet
+    ];
+    let result = "";
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (char) {
+            const colorIndex = i % colors.length;
+            const color = colors[colorIndex];
+            if (color) {
+                const [r, g, b] = color;
+                result += chalk.rgb(r, g, b)(char);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Create pulsing effect (alternating bright and dim)
+ */
+function pulse(text, color = "white") {
+    const chalk = new ChalkTS();
+    let result = "";
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (i % 2 === 0) {
+            result += chalk[color].bold(char);
+        }
+        else {
+            result += chalk[color].dim(char);
+        }
+    }
+    return result;
+}
+/**
+ * Create zebra stripes effect (alternating colors)
+ */
+function zebra(text, color1 = "white", color2 = "gray") {
+    const chalk = new ChalkTS();
+    let result = "";
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        const color = i % 2 === 0 ? color1 : color2;
+        result += chalk[color](char);
+    }
+    return result;
+}
+/**
+ * Create a neon effect
+ */
+function neon(text, color = "cyan") {
+    const chalk = new ChalkTS();
+    return chalk[color].bold.underline(text);
+}
+/**
+ * Create a shadow effect
+ */
+function shadow(text, color = "white", shadowColor = "gray") {
+    const chalk = new ChalkTS();
+    const lines = text.split("\n");
+    let result = "";
+    for (let i = 0; i < lines.length; i++) {
+        result += chalk[color](lines[i]);
+        if (i < lines.length - 1) {
+            result += "\n";
+        }
+    }
+    // Add shadow line
+    if (lines.length === 1) {
+        result += "\n" + chalk[shadowColor].dim(" ".repeat(text.length));
+    }
+    return result;
+}
+/**
+ * Create ASCII art box around text
+ */
+function box(text, options = {}) {
+    const { padding = 1, color = "white", style = "single" } = options;
+    const chalk = new ChalkTS();
+    const styles = {
+        single: {
+            top: "─",
+            bottom: "─",
+            left: "│",
+            right: "│",
+            topLeft: "┌",
+            topRight: "┐",
+            bottomLeft: "└",
+            bottomRight: "┘",
+        },
+        double: {
+            top: "═",
+            bottom: "═",
+            left: "║",
+            right: "║",
+            topLeft: "╔",
+            topRight: "╗",
+            bottomLeft: "╚",
+            bottomRight: "╝",
+        },
+        rounded: {
+            top: "─",
+            bottom: "─",
+            left: "│",
+            right: "│",
+            topLeft: "╭",
+            topRight: "╮",
+            bottomLeft: "╰",
+            bottomRight: "╯",
+        },
+        thick: {
+            top: "━",
+            bottom: "━",
+            left: "┃",
+            right: "┃",
+            topLeft: "┏",
+            topRight: "┓",
+            bottomLeft: "┗",
+            bottomRight: "┛",
+        },
+    };
+    const chars = styles[style];
+    const lines = text.split("\n");
+    const maxLength = Math.max(...lines.map((line) => line.length));
+    const width = maxLength + padding * 2;
+    const topLine = chalk[color](chars.topLeft + chars.top.repeat(width) + chars.topRight);
+    const bottomLine = chalk[color](chars.bottomLeft + chars.bottom.repeat(width) + chars.bottomRight);
+    let result = topLine + "\n";
+    // Add padding lines
+    for (let i = 0; i < padding; i++) {
+        result +=
+            chalk[color](chars.left + " ".repeat(width) + chars.right) +
+                "\n";
+    }
+    // Add content lines
+    for (const line of lines) {
+        const padLeft = " ".repeat(padding);
+        const padRight = " ".repeat(width - line.length - padding);
+        result +=
+            chalk[color](chars.left) +
+                padLeft +
+                line +
+                padRight +
+                chalk[color](chars.right) +
+                "\n";
+    }
+    // Add padding lines
+    for (let i = 0; i < padding; i++) {
+        result +=
+            chalk[color](chars.left + " ".repeat(width) + chars.right) +
+                "\n";
+    }
+    result += bottomLine;
+    return result;
+}
+/**
+ * Create a progress bar
+ */
+function progressBar(progress, total, options = {}) {
+    const { width = 20, complete = "█", incomplete = "░", showPercentage = true, color = "green", } = options;
+    const chalk = new ChalkTS();
+    const percentage = Math.min(100, Math.max(0, (progress / total) * 100));
+    const completedWidth = Math.round((percentage / 100) * width);
+    const remainingWidth = width - completedWidth;
+    const bar = chalk[color](complete.repeat(completedWidth)) +
+        chalk.gray(incomplete.repeat(remainingWidth));
+    if (showPercentage) {
+        return `${bar} ${percentage.toFixed(1)}%`;
+    }
+    return bar;
+}
+/**
+ * Create a spinner animation frame
+ */
+function spinner(frame, color = "cyan") {
+    const chalk = new ChalkTS();
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    const spinnerChar = frames[frame % frames.length];
+    return chalk[color](spinnerChar);
+}
+/**
+ * Create a table with colored headers and rows
+ */
+function table(data, options = {}) {
+    const { headers, headerColor = "cyan", borderColor = "gray", padding = 1, } = options;
+    const chalk = new ChalkTS();
+    if (data.length === 0)
+        return "";
+    const allRows = headers ? [headers, ...data] : data;
+    const firstRow = allRows[0];
+    if (!firstRow || firstRow.length === 0)
+        return "";
+    const columnWidths = firstRow.map((_, colIndex) => Math.max(...allRows.map((row) => row[colIndex]?.length || 0)));
+    let result = "";
+    // Top border
+    const topBorder = chalk[borderColor]("┌" + columnWidths.map((w) => "─".repeat(w + padding * 2)).join("┬") + "┐");
+    result += topBorder + "\n";
+    // Headers
+    if (headers) {
+        const headerRow = "│" +
+            headers
+                .map((header, i) => {
+                const width = columnWidths[i] || 0;
+                const padded = " ".repeat(padding) + header.padEnd(width) + " ".repeat(padding);
+                return chalk[headerColor].bold(padded);
+            })
+                .join(chalk[borderColor]("│")) +
+            chalk[borderColor]("│");
+        result += headerRow + "\n";
+        // Header separator
+        const separator = chalk[borderColor]("├" + columnWidths.map((w) => "─".repeat(w + padding * 2)).join("┼") + "┤");
+        result += separator + "\n";
+    }
+    // Data rows
+    const dataRows = headers ? data : allRows;
+    dataRows.forEach((row) => {
+        const tableRow = chalk[borderColor]("│") +
+            row
+                .map((cell, i) => {
+                const width = columnWidths[i] || 0;
+                const padded = " ".repeat(padding) +
+                    (cell || "").padEnd(width) +
+                    " ".repeat(padding);
+                return padded;
+            })
+                .join(chalk[borderColor]("│")) +
+            chalk[borderColor]("│");
+        result += tableRow + "\n";
+    });
+    // Bottom border
+    const bottomBorder = chalk[borderColor]("└" + columnWidths.map((w) => "─".repeat(w + padding * 2)).join("┴") + "┘");
+    result += bottomBorder;
+    return result;
+}
+
+exports.ANSI_CODES = ANSI_CODES;
+exports.COLORS = COLORS;
+exports.ChalkTS = ChalkTS;
+exports.bgBlack = bgBlack;
+exports.bgBlue = bgBlue;
+exports.bgBlueBright = bgBlueBright;
+exports.bgCyan = bgCyan;
+exports.bgCyanBright = bgCyanBright;
+exports.bgGray = bgGray;
+exports.bgGreen = bgGreen;
+exports.bgGreenBright = bgGreenBright;
+exports.bgGrey = bgGrey;
+exports.bgMagenta = bgMagenta;
+exports.bgMagentaBright = bgMagentaBright;
+exports.bgRed = bgRed;
+exports.bgRedBright = bgRedBright;
+exports.bgWhite = bgWhite;
+exports.bgWhiteBright = bgWhiteBright;
+exports.bgYellow = bgYellow;
+exports.bgYellowBright = bgYellowBright;
+exports.black = black;
+exports.blink = blink;
+exports.blue = blue;
+exports.blueBright = blueBright;
+exports.bold = bold;
+exports.box = box;
+exports.brown = brown;
+exports.chalk = chalkTs;
+exports.cyan = cyan;
+exports.cyanBright = cyanBright;
+exports.default = chalkTs;
+exports.dim = dim;
+exports.getColorLevel = getColorLevel;
+exports.gold = gold;
+exports.gradient = gradient;
+exports.gray = gray;
+exports.green = green;
+exports.greenBright = greenBright;
+exports.grey = grey;
+exports.hex = hex;
+exports.hexToRgb = hexToRgb;
+exports.hidden = hidden;
+exports.hsl = hsl;
+exports.hslToRgb = hslToRgb;
+exports.indigo = indigo;
+exports.inverse = inverse;
+exports.italic = italic;
+exports.lime = lime;
+exports.magenta = magenta;
+exports.magentaBright = magentaBright;
+exports.neon = neon;
+exports.orange = orange;
+exports.pink = pink;
+exports.progressBar = progressBar;
+exports.pulse = pulse;
+exports.purple = purple;
+exports.rainbow = rainbow;
+exports.red = red;
+exports.redBright = redBright;
+exports.rgb = rgb;
+exports.rgbToHex = rgbToHex;
+exports.rgbToHsl = rgbToHsl;
+exports.shadow = shadow;
+exports.silver = silver;
+exports.spinner = spinner;
+exports.strikethrough = strikethrough;
+exports.supportsColor = supportsColor;
+exports.table = table;
+exports.turquoise = turquoise;
+exports.underline = underline;
+exports.violet = violet;
+exports.white = white;
+exports.whiteBright = whiteBright;
+exports.yellow = yellow;
+exports.yellowBright = yellowBright;
+exports.zebra = zebra;
+//# sourceMappingURL=index.js.map