chalk-ts 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,807 @@
+/**
+ * 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;
+}
+
+export { ANSI_CODES, COLORS, ChalkTS, bgBlack, bgBlue, bgBlueBright, bgCyan, bgCyanBright, bgGray, bgGreen, bgGreenBright, bgGrey, bgMagenta, bgMagentaBright, bgRed, bgRedBright, bgWhite, bgWhiteBright, bgYellow, bgYellowBright, black, blink, blue, blueBright, bold, box, brown, chalkTs as chalk, cyan, cyanBright, chalkTs as default, dim, getColorLevel, gold, gradient, gray, green, greenBright, grey, hex, hexToRgb, hidden, hsl, hslToRgb, indigo, inverse, italic, lime, magenta, magentaBright, neon, orange, pink, progressBar, pulse, purple, rainbow, red, redBright, rgb, rgbToHex, rgbToHsl, shadow, silver, spinner, strikethrough, supportsColor, table, turquoise, underline, violet, white, whiteBright, yellow, yellowBright, zebra };
+//# sourceMappingURL=index.esm.js.map