@heinrichb/console-toolkit 1.0.9 → 1.0.13

package/dist/core/types.d.ts

@@ -5,7 +5,7 @@ export type StandardColor = "black" | "red" | "green" | "yellow" | "blue" | "mag
 /**
  * Text style modifiers.
  */
-export type StyleModifier = "bold" | "dim" | "italic" | "underline" | "default" | "hidden" | "inverse" | "strikethrough";
+export type StyleModifier = "bold" | "dim" | "italic" | "underline" | "hidden" | "inverse" | "strikethrough";
 /**
  * A valid Hex color string (e.g., "#FF0000").
  */
@@ -14,6 +14,14 @@ export type HexColor = `#${string}`;
  * A color can be a standard color name or a hex color string.
  */
 export type Color = StandardColor | HexColor;
+/**
+ * Represents an RGB color value.
+ */
+export interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
 /**
  * Represents the style configuration for a text segment, line, or block.
  */
@@ -24,6 +32,12 @@ export interface PrintStyle {
      * - An array of colors applies a gradient.
      */
     color?: Color | Color[];
+    /**
+     * The background color to apply.
+     * - A single color (string) applies a solid background.
+     * - An array of colors applies a background gradient.
+     */
+    bgColor?: Color | Color[];
     /**
      * A list of style modifiers (e.g., bold, italic) to apply.
      */

package/dist/core/utils.d.ts

@@ -17,9 +17,16 @@ export declare function computeMaxWidth(lines: PrintLine[]): number;
 /**
  * Pads a PrintLine to a target width by adding an empty segment at the end.
  *
- * @param line - The line to pad.
+ * @param inputLine - The line to pad.
  * @param targetWidth - The desired minimum width.
  * @param padStyle - The style to apply to the padding spaces.
  * @returns A new PrintLine with padding added if necessary.
  */
-export declare function padLine(line: PrintLine, targetWidth: number, padStyle?: PrintStyle): PrintLine;
+export declare function padLine(inputLine: PrintLine, targetWidth: number, padStyle?: PrintStyle): PrintLine;
+/**
+ * Strips all ANSI escape sequences from a string, returning plain text.
+ *
+ * @param text - The string potentially containing ANSI codes.
+ * @returns The plain text with all ANSI sequences removed.
+ */
+export declare function stripAnsi(text: string): string;

package/dist/index.d.ts

@@ -1,8 +1,11 @@
 export * from "./core/types";
 export * from "./core/style";
 export * from "./core/utils";
+export * from "./core/builders";
 export * from "./core/printer";
 export * from "./core/layout";
 export * from "./components/progress";
 export * from "./components/spinner";
+export * from "./components/table";
 export * from "./presets/ascii";
+export * from "./presets/gradients";

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/core/style.ts
 var ESC = "\x1B";
 var RESET = `${ESC}[0m`;
-var STANDARD_COLORS = {
+var STANDARD_COLORS = Object.assign(Object.create(null), {
   black: "#000000",
   red: "#EF4444",
   green: "#10B981",
@@ -12,9 +12,8 @@ var STANDARD_COLORS = {
   white: "#FFFFFF",
   gray: "#6B7280",
   grey: "#6B7280"
-};
-var MODIFIER_CODES = {
-  default: "0",
+});
+var MODIFIER_CODES = Object.assign(Object.create(null), {
   bold: "1",
   dim: "2",
   italic: "3",
@@ -22,7 +21,7 @@ var MODIFIER_CODES = {
   inverse: "7",
   hidden: "8",
   strikethrough: "9"
-};
+});
 function colorToHex(color) {
   if (color.startsWith("#"))
     return color;
@@ -44,11 +43,17 @@ function hexToRgb(hex) {
 function rgbToAnsi(r, g, b) {
   return `${ESC}[38;2;${r};${g};${b}m`;
 }
+function rgbToBgAnsi(r, g, b) {
+  return `${ESC}[48;2;${r};${g};${b}m`;
+}
 function resolveColorToAnsi(color) {
-  const hex = colorToHex(color);
-  const { r, g, b } = hexToRgb(hex);
+  const { r, g, b } = resolveColorToRgb(color);
   return rgbToAnsi(r, g, b);
 }
+function resolveColorToRgb(color) {
+  const hex = colorToHex(color);
+  return hexToRgb(hex);
+}
 function resolveModifiersToAnsi(modifiers) {
   if (!modifiers || modifiers.length === 0)
     return "";
@@ -70,22 +75,38 @@ function interpolateHex(color1, color2, factor) {
   const b = c1.b + f * (c2.b - c1.b);
   return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
 }
-function interpolateColor(color1, color2, factor) {
-  return interpolateHex(colorToHex(color1), colorToHex(color2), factor);
+function gradientSegment(colorCount, factor) {
+  const f = Math.max(0, Math.min(1, factor));
+  const segmentLength = 1 / (colorCount - 1);
+  const index = Math.min(Math.floor(f / segmentLength), colorCount - 2);
+  return { index, factor: (f - index * segmentLength) / segmentLength };
 }
-function getGradientColor(colors, factor) {
+function getGradientAnsiFromRgb(colors, factor, toAnsi) {
   if (colors.length === 0)
     return "";
   if (colors.length === 1)
-    return resolveColorToAnsi(colors[0]);
-  const f = Math.max(0, Math.min(1, factor));
-  const segmentLength = 1 / (colors.length - 1);
-  const segmentIndex = Math.min(Math.floor(f / segmentLength), colors.length - 2);
-  const segmentFactor = (f - segmentIndex * segmentLength) / segmentLength;
-  const c1 = colors[segmentIndex];
-  const c2 = colors[segmentIndex + 1];
-  const hex = interpolateColor(c1, c2, segmentFactor);
-  return resolveColorToAnsi(hex);
+    return toAnsi(colors[0].r, colors[0].g, colors[0].b);
+  const seg = gradientSegment(colors.length, factor);
+  const c1 = colors[seg.index];
+  const c2 = colors[seg.index + 1];
+  const r = Math.round(c1.r + seg.factor * (c2.r - c1.r));
+  const g = Math.round(c1.g + seg.factor * (c2.g - c1.g));
+  const b = Math.round(c1.b + seg.factor * (c2.b - c1.b));
+  return toAnsi(r, g, b);
+}
+function getGradientColorFromRgb(colors, factor) {
+  return getGradientAnsiFromRgb(colors, factor, rgbToAnsi);
+}
+function getGradientBgColorFromRgb(colors, factor) {
+  return getGradientAnsiFromRgb(colors, factor, rgbToBgAnsi);
+}
+function interpolateGradient(colors, factor) {
+  if (colors.length === 0)
+    return "#FFFFFF";
+  if (colors.length === 1)
+    return colorToHex(colors[0]);
+  const seg = gradientSegment(colors.length, factor);
+  return interpolateHex(colorToHex(colors[seg.index]), colorToHex(colors[seg.index + 1]), seg.factor);
 }
 function mergeStyles(parent, child) {
   if (!parent && !child)
@@ -94,10 +115,17 @@ function mergeStyles(parent, child) {
     return child ?? {};
   if (!child)
     return parent;
-  const mergedModifiers = Array.from(new Set([...parent.modifiers ?? [], ...child.modifiers ?? []]));
+  const parentMods = parent.modifiers ?? [];
+  const childMods = child.modifiers ?? [];
+  const mergedModifiers = [...parentMods];
+  for (const mod of childMods) {
+    if (!mergedModifiers.includes(mod))
+      mergedModifiers.push(mod);
+  }
   return {
     modifiers: mergedModifiers,
-    color: child.color ?? parent.color
+    color: child.color ?? parent.color,
+    bgColor: child.bgColor ?? parent.bgColor
   };
 }
 function resolveStyle(style, gradientFactor = 0) {
@@ -109,33 +137,53 @@ function resolveStyle(style, gradientFactor = 0) {
   }
   if (style.color) {
     if (Array.isArray(style.color)) {
-      const hex = getGradientColor(style.color, gradientFactor);
-      ansi += hex;
+      const rgbColors = style.color.map(resolveColorToRgb);
+      ansi += getGradientColorFromRgb(rgbColors, gradientFactor);
     } else {
       ansi += resolveColorToAnsi(style.color);
     }
   }
+  if (style.bgColor) {
+    if (Array.isArray(style.bgColor)) {
+      const bgRgbColors = style.bgColor.map(resolveColorToRgb);
+      ansi += getGradientBgColorFromRgb(bgRgbColors, gradientFactor);
+    } else {
+      const { r, g, b } = resolveColorToRgb(style.bgColor);
+      ansi += rgbToBgAnsi(r, g, b);
+    }
+  }
   return ansi;
 }
+// src/core/builders.ts
+function segment(text, style) {
+  return { text, style };
+}
+function line(segments = [], style) {
+  return { segments, style };
+}
+function block(lines = [], style) {
+  return { lines, style };
+}
+
 // src/core/utils.ts
-function getLineLength(line) {
-  return line.segments.reduce((acc, seg) => acc + seg.text.length, 0);
+function getLineLength(line2) {
+  return line2.segments.reduce((acc, seg) => acc + seg.text.length, 0);
 }
 function computeMaxWidth(lines) {
-  return lines.length > 0 ? Math.max(...lines.map(getLineLength)) : 0;
+  return lines.reduce((max, l) => Math.max(max, getLineLength(l)), 0);
 }
-function padLine(line, targetWidth, padStyle) {
-  const currentLength = getLineLength(line);
+function padLine(inputLine, targetWidth, padStyle) {
+  const currentLength = getLineLength(inputLine);
   if (currentLength < targetWidth) {
-    return {
-      segments: [...line.segments, { text: " ".repeat(targetWidth - currentLength), style: padStyle }]
-    };
+    return line([...inputLine.segments, segment(" ".repeat(targetWidth - currentLength), padStyle)], inputLine.style);
   }
-  return line;
+  return inputLine;
+}
+var ANSI_REGEX = /\x1b\[[0-9;]*m/g;
+function stripAnsi(text) {
+  return text.replace(ANSI_REGEX, "");
 }
 // src/core/printer.ts
-var ESC2 = "\x1B";
-
 class Printer {
   linesRendered = 0;
   isLive;
@@ -147,7 +195,7 @@ class Printer {
   getClearSequence() {
     if (!this.isLive || this.linesRendered === 0)
       return "";
-    return `${ESC2}[1A${ESC2}[2K\r`.repeat(this.linesRendered);
+    return `${ESC}[1A${ESC}[2K\r`.repeat(this.linesRendered);
   }
   clear() {
     if (this.linesRendered > 0) {
@@ -155,6 +203,14 @@ class Printer {
       this.linesRendered = 0;
     }
   }
+  renderToString(data) {
+    if (data) {
+      this.data = data;
+    }
+    if (!this.data)
+      return "";
+    return this.renderBlock(this.data);
+  }
   print(data) {
     if (data) {
       this.data = data;
@@ -162,51 +218,67 @@ class Printer {
     if (!this.data) {
       return;
     }
-    let output = this.getClearSequence();
-    const lines = this.data.lines;
-    const blockStyle = this.data.style ?? {};
-    lines.forEach((line, lineIndex) => {
-      output += this.renderLine(line, lineIndex, lines.length, blockStyle);
+    const output = this.getClearSequence() + this.renderBlock(this.data);
+    process.stdout.write(output);
+    this.linesRendered = this.data.lines.length;
+  }
+  renderBlock(blockData) {
+    let output = "";
+    const lines = blockData.lines;
+    const blockStyle = blockData.style ?? {};
+    lines.forEach((ln, lineIndex) => {
+      output += this.renderLine(ln, lineIndex, lines.length, blockStyle);
       output += `
 `;
     });
-    process.stdout.write(output);
-    this.linesRendered = lines.length;
+    return output;
   }
-  resolveBlockColorForLine(blockStyle, lineIndex, totalLines) {
-    if (!blockStyle.color)
+  resolveBlockStyleForLine(blockStyle, lineIndex, totalLines) {
+    return {
+      modifiers: blockStyle.modifiers,
+      color: this.resolveGradientForLine(blockStyle.color, lineIndex, totalLines),
+      bgColor: this.resolveGradientForLine(blockStyle.bgColor, lineIndex, totalLines)
+    };
+  }
+  resolveGradientForLine(color, lineIndex, totalLines) {
+    if (!color)
       return;
-    if (Array.isArray(blockStyle.color)) {
+    if (Array.isArray(color)) {
       if (totalLines <= 1)
-        return blockStyle.color[0];
-      const colors = blockStyle.color;
-      const factor = lineIndex / (totalLines - 1);
-      const f = Math.max(0, Math.min(1, factor));
-      const segmentLength = 1 / (colors.length - 1);
-      const segmentIndex = Math.min(Math.floor(f / segmentLength), colors.length - 2);
-      const segmentFactor = (f - segmentIndex * segmentLength) / segmentLength;
-      const c1 = colors[segmentIndex];
-      const c2 = colors[segmentIndex + 1];
-      return interpolateColor(c1, c2, segmentFactor);
+        return color[0];
+      return interpolateGradient(color, lineIndex / (totalLines - 1));
     }
-    return blockStyle.color;
+    return color;
   }
-  renderLine(line, lineIndex, totalLines, parentBlockStyle) {
-    const blockColorForLine = this.resolveBlockColorForLine(parentBlockStyle, lineIndex, totalLines);
-    const baseLineStyle = {
-      modifiers: parentBlockStyle.modifiers,
-      color: blockColorForLine
-    };
-    const effectiveLineStyle = mergeStyles(baseLineStyle, line.style);
-    const totalChars = line.segments.reduce((acc, seg) => acc + seg.text.length, 0);
+  renderLine(line2, lineIndex, totalLines, parentBlockStyle) {
+    const baseLineStyle = this.resolveBlockStyleForLine(parentBlockStyle, lineIndex, totalLines);
+    const effectiveLineStyle = mergeStyles(baseLineStyle, line2.style);
+    const totalChars = line2.segments.reduce((acc, seg) => acc + seg.text.length, 0);
     let currentCharIndex = 0;
     let lineOutput = "";
-    line.segments.forEach((seg) => {
+    line2.segments.forEach((seg) => {
       const effectiveSegmentStyle = mergeStyles(effectiveLineStyle, seg.style);
-      if (Array.isArray(effectiveSegmentStyle.color)) {
-        const colors = effectiveSegmentStyle.color;
+      const hasFgGradient = Array.isArray(effectiveSegmentStyle.color);
+      const hasBgGradient = Array.isArray(effectiveSegmentStyle.bgColor);
+      if (hasFgGradient || hasBgGradient) {
         const text = seg.text;
         const isGlobalGradient = effectiveSegmentStyle.color === effectiveLineStyle.color;
+        let fgRgbColors;
+        let solidFgAnsi = "";
+        if (hasFgGradient) {
+          fgRgbColors = effectiveSegmentStyle.color.map(resolveColorToRgb);
+        } else if (effectiveSegmentStyle.color) {
+          const { r, g, b } = resolveColorToRgb(effectiveSegmentStyle.color);
+          solidFgAnsi = rgbToAnsi(r, g, b);
+        }
+        let bgRgbColors;
+        let solidBgAnsi = "";
+        if (hasBgGradient) {
+          bgRgbColors = effectiveSegmentStyle.bgColor.map(resolveColorToRgb);
+        } else if (effectiveSegmentStyle.bgColor) {
+          const { r, g, b } = resolveColorToRgb(effectiveSegmentStyle.bgColor);
+          solidBgAnsi = rgbToBgAnsi(r, g, b);
+        }
         const modifiersAnsi = resolveModifiersToAnsi(effectiveSegmentStyle.modifiers);
         for (let i = 0;i < text.length; i++) {
           let factor = 0;
@@ -215,8 +287,9 @@ class Printer {
           } else if (!isGlobalGradient && text.length > 1) {
             factor = i / (text.length - 1);
           }
-          const colorAnsi = getGradientColor(colors, factor);
-          lineOutput += `${modifiersAnsi}${colorAnsi}${text[i]}`;
+          const fgAnsi = fgRgbColors ? getGradientColorFromRgb(fgRgbColors, factor) : solidFgAnsi;
+          const bgAnsi = bgRgbColors ? getGradientBgColorFromRgb(bgRgbColors, factor) : solidBgAnsi;
+          lineOutput += `${modifiersAnsi}${fgAnsi}${bgAnsi}${text[i]}`;
         }
         lineOutput += RESET;
       } else {
@@ -232,7 +305,7 @@ class Printer {
 function mergeColumns(columns, separator = "     ", defaultStyle, widths) {
   if (columns.length === 0)
     return [];
-  const maxLines = Math.max(...columns.map((c) => c.length));
+  const maxLines = columns.reduce((max, c) => Math.max(max, c.length), 0);
   const colWidths = columns.map((col, i) => {
     if (widths?.[i] !== undefined)
       return widths[i];
@@ -240,24 +313,24 @@ function mergeColumns(columns, separator = "     ", defaultStyle, widths) {
   });
   const output = [];
   for (let i = 0;i < maxLines; i++) {
-    let segments = [];
+    const segments = [];
     for (let j = 0;j < columns.length; j++) {
-      const line = columns[j][i] || { segments: [] };
+      const currentLine = columns[j][i] || line();
       if (j < columns.length - 1) {
-        const padded = padLine(line, colWidths[j], defaultStyle);
-        segments = [...segments, ...padded.segments, { text: separator, style: defaultStyle }];
+        const padded = padLine(currentLine, colWidths[j], defaultStyle);
+        segments.push(...padded.segments, segment(separator, defaultStyle));
       } else {
-        segments = [...segments, ...line.segments];
+        segments.push(...currentLine.segments);
       }
     }
-    output.push({ segments });
+    output.push(line(segments));
   }
   return output;
 }
 function printColumns(columns, options = {}) {
-  const { widths, separator = "     ", printer = new Printer } = options;
-  const mergedLines = mergeColumns(columns, separator, undefined, widths);
-  printer.print({ lines: mergedLines });
+  const { widths, separator = "     ", defaultStyle, printer = new Printer } = options;
+  const mergedLines = mergeColumns(columns, separator, defaultStyle, widths);
+  printer.print(block(mergedLines));
 }
 // src/components/progress.ts
 function createProgressBar(options) {
@@ -275,7 +348,9 @@ function createProgressBar(options) {
     startChar = "[",
     endChar = "]",
     fillChar = "█",
+    completeChar,
     emptyChar = "░",
+    completeStyle,
     showPercentage = true,
     formatPercentage
   } = options;
@@ -286,27 +361,29 @@ function createProgressBar(options) {
   const resolvedStartStyle = startStyle ?? resolvedBracketStyle;
   const resolvedEndStyle = endStyle ?? resolvedBracketStyle;
   const resolvedBarStyle = barStyle ?? style;
-  const resolvedFillStyle = fillStyle ?? resolvedBarStyle;
+  const isComplete = p >= 1;
+  const resolvedFillStyle = isComplete ? completeStyle ?? fillStyle ?? resolvedBarStyle : fillStyle ?? resolvedBarStyle;
   const resolvedEmptyStyle = emptyStyle ?? resolvedBarStyle;
   const resolvedPercentageStyle = percentageStyle ?? style;
   const segments = [];
   if (startChar) {
-    segments.push({ text: startChar, style: resolvedStartStyle });
+    segments.push(segment(startChar, resolvedStartStyle));
   }
+  const effectiveFillChar = isComplete ? completeChar ?? fillChar : fillChar;
   if (filledWidth > 0) {
-    segments.push({ text: fillChar.repeat(filledWidth), style: resolvedFillStyle });
+    segments.push(segment(effectiveFillChar.repeat(filledWidth), resolvedFillStyle));
   }
   if (emptyWidth > 0) {
-    segments.push({ text: emptyChar.repeat(emptyWidth), style: resolvedEmptyStyle });
+    segments.push(segment(emptyChar.repeat(emptyWidth), resolvedEmptyStyle));
   }
   if (endChar) {
-    segments.push({ text: endChar, style: resolvedEndStyle });
+    segments.push(segment(endChar, resolvedEndStyle));
   }
   if (showPercentage) {
     const percentageText = formatPercentage ? formatPercentage(p) : ` ${Math.round(p * 100)}%`;
-    segments.push({ text: percentageText, style: resolvedPercentageStyle });
+    segments.push(segment(percentageText, resolvedPercentageStyle));
   }
-  return { segments };
+  return line(segments);
 }
 // src/components/spinner.ts
 var SPINNERS = {
@@ -333,8 +410,133 @@ class Spinner {
     return this.frames[index];
   }
 }
+// src/components/table.ts
+var BORDERS = {
+  single: {
+    tl: "┌",
+    t: "─",
+    tr: "┐",
+    l: "│",
+    r: "│",
+    bl: "└",
+    b: "─",
+    br: "┘",
+    ml: "├",
+    m: "─",
+    mr: "┤",
+    tj: "┬",
+    bj: "┴",
+    mj: "┼"
+  },
+  double: {
+    tl: "╔",
+    t: "═",
+    tr: "╗",
+    l: "║",
+    r: "║",
+    bl: "╚",
+    b: "═",
+    br: "╝",
+    ml: "╠",
+    m: "═",
+    mr: "╣",
+    tj: "╦",
+    bj: "╩",
+    mj: "╬"
+  },
+  rounded: {
+    tl: "╭",
+    t: "─",
+    tr: "╮",
+    l: "│",
+    r: "│",
+    bl: "╰",
+    b: "─",
+    br: "╯",
+    ml: "├",
+    m: "─",
+    mr: "┤",
+    tj: "┬",
+    bj: "┴",
+    mj: "┼"
+  }
+};
+function buildBorderLine(left, fill, junction, right, colWidths, padding, borderStyle) {
+  const parts = [left];
+  for (let i = 0;i < colWidths.length; i++) {
+    parts.push(fill.repeat(colWidths[i] + padding * 2));
+    if (i < colWidths.length - 1)
+      parts.push(junction);
+  }
+  parts.push(right);
+  return line([segment(parts.join(""), borderStyle)]);
+}
+function buildDataRow(cells, colWidths, padding, colCount, borderChar, cellStyle, borderStyle) {
+  const segments = [];
+  segments.push(segment(borderChar, borderStyle));
+  for (let i = 0;i < colCount; i++) {
+    const cellText = cells[i] ?? "";
+    const padded = " ".repeat(padding) + cellText.padEnd(colWidths[i]) + " ".repeat(padding);
+    segments.push(segment(padded, cellStyle));
+    if (i < colCount - 1) {
+      segments.push(segment(borderChar, borderStyle));
+    }
+  }
+  segments.push(segment(borderChar, borderStyle));
+  return line(segments);
+}
+function createTable(options) {
+  const { headers, rows, style, headerStyle, borderStyle, border = "single", columnWidths, cellPadding = 1 } = options;
+  const colCount = rows.reduce((max, r) => Math.max(max, r.length), headers?.length ?? 0);
+  if (colCount === 0)
+    return [];
+  const colWidths = [];
+  for (let i = 0;i < colCount; i++) {
+    if (columnWidths?.[i] !== undefined) {
+      colWidths.push(columnWidths[i]);
+    } else {
+      const headerWidth = headers?.[i]?.length ?? 0;
+      const maxRowWidth = rows.reduce((max, row) => Math.max(max, row[i]?.length ?? 0), 0);
+      colWidths.push(Math.max(headerWidth, maxRowWidth));
+    }
+  }
+  if (border === "none") {
+    return buildNoBorderTable(headers, rows, colWidths, cellPadding, colCount, style, headerStyle);
+  }
+  const chars = BORDERS[border];
+  const output = [];
+  output.push(buildBorderLine(chars.tl, chars.t, chars.tj, chars.tr, colWidths, cellPadding, borderStyle));
+  if (headers) {
+    output.push(buildDataRow(headers, colWidths, cellPadding, colCount, chars.l, headerStyle ?? style, borderStyle));
+    output.push(buildBorderLine(chars.ml, chars.m, chars.mj, chars.mr, colWidths, cellPadding, borderStyle));
+  }
+  for (const row of rows) {
+    output.push(buildDataRow(row, colWidths, cellPadding, colCount, chars.l, style, borderStyle));
+  }
+  output.push(buildBorderLine(chars.bl, chars.b, chars.bj, chars.br, colWidths, cellPadding, borderStyle));
+  return output;
+}
+function buildNoBorderTable(headers, rows, colWidths, padding, colCount, style, headerStyle) {
+  const output = [];
+  const space = " ".repeat(padding);
+  function buildRow(cells, cellStyle) {
+    const segments = [];
+    for (let i = 0;i < colCount; i++) {
+      const cellText = cells[i] ?? "";
+      segments.push(segment(space + cellText.padEnd(colWidths[i]) + space, cellStyle));
+    }
+    return line(segments);
+  }
+  if (headers) {
+    output.push(buildRow(headers, headerStyle ?? style));
+  }
+  for (const row of rows) {
+    output.push(buildRow(row, style));
+  }
+  return output;
+}
 // src/presets/ascii.ts
-function getDragon(startColor = "#EF4444", endColor = "#F59E0B") {
+function getDragon(colors = ["#EF4444", "#F59E0B"]) {
   const rawDragon = [
     "                ^    ^",
     "               / \\  //\\",
@@ -356,30 +558,49 @@ function getDragon(startColor = "#EF4444", endColor = "#F59E0B") {
   ];
   return rawDragon.map((text, i) => {
     const factor = rawDragon.length <= 1 ? 0 : i / (rawDragon.length - 1);
-    const colorStyle = interpolateColor(startColor, endColor, factor);
-    return { segments: [{ text, style: { color: colorStyle } }] };
+    const color = interpolateGradient(colors, factor);
+    return line([segment(text, { color })]);
   });
 }
+// src/presets/gradients.ts
+var GRADIENTS = {
+  rainbow: ["#EF4444", "#F59E0B", "#10B981", "#06B6D4", "#3B82F6", "#8B5CF6"],
+  ocean: ["#1E3A5F", "#0E7490", "#06B6D4", "#67E8F9"],
+  fire: ["#7F1D1D", "#EF4444", "#F59E0B", "#FDE047"],
+  sunset: ["#7C3AED", "#EC4899", "#F97316", "#FBBF24"],
+  forest: ["#064E3B", "#10B981", "#84CC16", "#BEF264"],
+  monochrome: ["#000000", "#6B7280", "#FFFFFF"]
+};
 export {
+  stripAnsi,
+  segment,
+  rgbToBgAnsi,
   rgbToAnsi,
   resolveStyle,
   resolveModifiersToAnsi,
+  resolveColorToRgb,
   resolveColorToAnsi,
   printColumns,
   padLine,
   mergeStyles,
   mergeColumns,
+  line,
   interpolateHex,
-  interpolateColor,
+  interpolateGradient,
   hexToRgb,
   getLineLength,
-  getGradientColor,
+  getGradientColorFromRgb,
+  getGradientBgColorFromRgb,
   getDragon,
+  createTable,
   createProgressBar,
   computeMaxWidth,
   colorToHex,
+  block,
   Spinner,
   SPINNERS,
   RESET,
-  Printer
+  Printer,
+  GRADIENTS,
+  ESC
 };