@mdxui/terminal 2.0.0

package/dist/chunk-X24GWXQV.js

@@ -0,0 +1,1281 @@
+// src/renderers/utils.ts
+function getIndentStr(level) {
+  return "  ".repeat(Math.max(0, level));
+}
+function getTextWidth(text) {
+  return text.length;
+}
+function padText(text, width, align = "left", padChar = " ") {
+  const textLen = getTextWidth(text);
+  if (textLen >= width) {
+    return text.slice(0, width);
+  }
+  const totalPad = width - textLen;
+  const padStr = padChar.repeat(totalPad);
+  switch (align) {
+    case "center":
+      const leftPad = Math.floor(totalPad / 2);
+      const rightPad = totalPad - leftPad;
+      return padChar.repeat(leftPad) + text + padChar.repeat(rightPad);
+    case "right":
+      return padStr + text;
+    case "left":
+    default:
+      return text + padStr;
+  }
+}
+function wrapText(text, maxWidth) {
+  if (maxWidth <= 0) {
+    return [text];
+  }
+  const normalized = text.replace(/[ \t]+/g, " ");
+  const lines = [];
+  const paragraphs = normalized.split("\n");
+  for (const paragraph of paragraphs) {
+    if (paragraph.length === 0) {
+      lines.push("");
+      continue;
+    }
+    const words = paragraph.split(" ").filter((w) => w.length > 0);
+    let currentLine = "";
+    for (const word of words) {
+      if (word.length > maxWidth) {
+        if (currentLine.length > 0) {
+          lines.push(currentLine);
+          currentLine = "";
+        }
+        let remaining = word;
+        while (remaining.length > maxWidth) {
+          lines.push(remaining.slice(0, maxWidth));
+          remaining = remaining.slice(maxWidth);
+        }
+        if (remaining.length > 0) {
+          currentLine = remaining;
+        }
+      } else if (currentLine.length === 0) {
+        currentLine = word;
+      } else if (currentLine.length + 1 + word.length <= maxWidth) {
+        currentLine += " " + word;
+      } else {
+        lines.push(currentLine);
+        currentLine = word;
+      }
+    }
+    if (currentLine.length > 0 || paragraph.length === 0) {
+      lines.push(currentLine);
+    }
+  }
+  return lines;
+}
+function sanitizeToASCII(text) {
+  let result = "";
+  for (const char of text) {
+    const code = char.codePointAt(0) ?? 0;
+    if (code <= 127) {
+      result += char;
+    } else if (char === "\u2022" || char === "\u25CF" || char === "\u25CB" || char === "\u25A0") {
+      result += "*";
+    } else if (code >= 9472 && code <= 9599) {
+      result += boxDrawingToASCII(char);
+    } else if (code >= 128512 && code <= 128591 || code > 65536) {
+      result += "";
+    } else {
+      result += "";
+    }
+  }
+  return result;
+}
+function boxDrawingToASCII(char) {
+  const code = char.codePointAt(0) ?? 0;
+  if ([9472, 9473, 9476, 9477, 9480, 9481, 9548, 9549].includes(code)) {
+    return "-";
+  }
+  if ([9474, 9475, 9478, 9479, 9482, 9483, 9550, 9551].includes(code)) {
+    return "|";
+  }
+  return "+";
+}
+function buildBox(chars, contentLines, width) {
+  if (width <= 0) return [];
+  if (width <= 2) return [chars.topLeft + chars.topRight];
+  const innerWidth = width - 2;
+  const lines = [];
+  lines.push(chars.topLeft + chars.horizontal.repeat(innerWidth) + chars.topRight);
+  for (const lineContent of contentLines) {
+    const paddedContent = padText(lineContent, innerWidth, "left");
+    lines.push(chars.vertical + paddedContent.slice(0, innerWidth) + chars.vertical);
+  }
+  lines.push(chars.bottomLeft + chars.horizontal.repeat(innerWidth) + chars.bottomRight);
+  return lines;
+}
+function extractStringArray(items) {
+  if (!Array.isArray(items)) return [];
+  return items.map((item) => {
+    if (typeof item === "string") {
+      return item;
+    }
+    if (typeof item === "object" && item !== null && "text" in item) {
+      return String(item.text);
+    }
+    return String(item);
+  });
+}
+function extractHeaders(columns) {
+  if (!Array.isArray(columns)) return [];
+  return columns.map((col) => col.header || col.key || "");
+}
+function extractRowValues(row, columns) {
+  if (!Array.isArray(columns)) return [];
+  return columns.map((col) => {
+    const val = row[col.key];
+    return val != null ? String(val) : "";
+  });
+}
+function joinParts(parts, separator = "\n\n") {
+  return parts.filter((p) => p.length > 0).join(separator);
+}
+function getProp(obj, key, defaultValue) {
+  const val = obj[key];
+  return val === void 0 ? defaultValue : val;
+}
+var DEFAULT_THEME_TOKENS = {
+  primary: "",
+  secondary: "",
+  muted: "",
+  foreground: "",
+  background: "",
+  border: "",
+  success: "",
+  warning: "",
+  error: "",
+  info: ""
+};
+var DEFAULT_RENDER_CONTEXT = {
+  width: 80,
+  height: 24,
+  depth: 0
+};
+var ASCII_BOX_CHARS = {
+  topLeft: "+",
+  topRight: "+",
+  bottomLeft: "+",
+  bottomRight: "+",
+  horizontal: "-",
+  vertical: "|"
+};
+var ASCII_DOUBLE_BOX_CHARS = {
+  topLeft: "+",
+  topRight: "+",
+  bottomLeft: "+",
+  bottomRight: "+",
+  horizontal: "=",
+  vertical: "|"
+};
+var UNICODE_SINGLE_BOX_CHARS = {
+  topLeft: "\u250C",
+  topRight: "\u2510",
+  bottomLeft: "\u2514",
+  bottomRight: "\u2518",
+  horizontal: "\u2500",
+  vertical: "\u2502"
+};
+var UNICODE_DOUBLE_BOX_CHARS = {
+  topLeft: "\u2554",
+  topRight: "\u2557",
+  bottomLeft: "\u255A",
+  bottomRight: "\u255D",
+  horizontal: "\u2550",
+  vertical: "\u2551"
+};
+var UNICODE_ROUNDED_BOX_CHARS = {
+  topLeft: "\u256D",
+  topRight: "\u256E",
+  bottomLeft: "\u2570",
+  bottomRight: "\u256F",
+  horizontal: "\u2500",
+  vertical: "\u2502"
+};
+function getASCIIBoxChars(style) {
+  if (style === "double") {
+    return ASCII_DOUBLE_BOX_CHARS;
+  }
+  return ASCII_BOX_CHARS;
+}
+function getUnicodeBoxChars(style) {
+  switch (style) {
+    case "double":
+      return UNICODE_DOUBLE_BOX_CHARS;
+    case "rounded":
+      return UNICODE_ROUNDED_BOX_CHARS;
+    case "single":
+    default:
+      return UNICODE_SINGLE_BOX_CHARS;
+  }
+}
+var UNICODE_SYMBOLS = {
+  // Bullets and list markers
+  bullet: "\u2022",
+  hollowBullet: "\u25E6",
+  squareBullet: "\u25AA",
+  triangleRight: "\u25B8",
+  triangleDown: "\u25BE",
+  checkmark: "\u2713",
+  crossMark: "\u2717",
+  unchecked: "\u2610",
+  arrowRight: "\u2192",
+  arrowDown: "\u2193",
+  // Progress bar characters
+  progressFull: "\u2593",
+  progressEmpty: "\u2591",
+  progressHalf: "\u2592",
+  // Dividers
+  ellipsis: "\u2026",
+  middleDot: "\xB7",
+  // Table junction characters
+  teeLeft: "\u251C",
+  teeRight: "\u2524",
+  teeTop: "\u252C",
+  teeBottom: "\u2534",
+  crossJunction: "\u253C"
+};
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function calculateColumnWidths(headers, rows, maxTableWidth) {
+  const columnCount = Math.max(headers.length, ...rows.map((r) => r.length));
+  const colWidths = [];
+  for (let i = 0; i < columnCount; i++) {
+    let maxWidth = headers[i]?.length ?? 0;
+    for (const row of rows) {
+      const cellLen = (row[i] ?? "").length;
+      maxWidth = Math.max(maxWidth, cellLen);
+    }
+    colWidths.push(maxWidth);
+  }
+  if (maxTableWidth && maxTableWidth > 0 && columnCount > 0) {
+    const totalWidth = colWidths.reduce((a, b) => a + b, 0) + columnCount + 1;
+    if (totalWidth > maxTableWidth) {
+      const availableForContent = maxTableWidth - columnCount - 1;
+      const maxPerColumn = Math.max(1, Math.floor(availableForContent / columnCount));
+      for (let i = 0; i < colWidths.length; i++) {
+        colWidths[i] = Math.min(colWidths[i], maxPerColumn);
+      }
+    }
+  }
+  return colWidths;
+}
+function buildTableSeparator(colWidths, chars) {
+  return chars.left + colWidths.map((w) => chars.horizontal.repeat(w)).join(chars.middle) + chars.right;
+}
+function buildTableRow(cells, colWidths, vertical) {
+  const parts = colWidths.map((w, i) => {
+    const cell = cells[i] ?? "";
+    const truncated = cell.length > w ? cell.slice(0, w) : cell;
+    return truncated.padEnd(w);
+  });
+  return vertical + parts.join(vertical) + vertical;
+}
+function createCallbackRouterAdapter(config) {
+  return {
+    getCurrentPath: () => config.currentPath || "/",
+    navigate: (path) => config.onNavigate?.(path),
+    isActive: (path, mode = "exact") => {
+      const current = config.currentPath || "/";
+      return matchPath(current, path, mode);
+    }
+  };
+}
+function matchPath(currentPath, targetPath, mode = "exact") {
+  const normCurrent = normalizePath(currentPath);
+  const normTarget = normalizePath(targetPath);
+  switch (mode) {
+    case "exact":
+      return normCurrent === normTarget;
+    case "prefix":
+      if (normTarget === "/") {
+        return normCurrent === "/";
+      }
+      return normCurrent === normTarget || normCurrent.startsWith(normTarget + "/");
+    case "pattern":
+      return matchPathPattern(normCurrent, normTarget);
+    default:
+      return normCurrent === normTarget;
+  }
+}
+function normalizePath(path) {
+  if (!path || path === "/") return "/";
+  const normalized = path.endsWith("/") ? path.slice(0, -1) : path;
+  return normalized.startsWith("/") ? normalized : "/" + normalized;
+}
+function matchPathPattern(path, pattern) {
+  if (pattern.endsWith("*")) {
+    const prefix = pattern.slice(0, -1);
+    return path.startsWith(prefix);
+  }
+  const pathSegments = path.split("/").filter(Boolean);
+  const patternSegments = pattern.split("/").filter(Boolean);
+  if (pathSegments.length !== patternSegments.length) {
+    return false;
+  }
+  for (let i = 0; i < patternSegments.length; i++) {
+    const patternSeg = patternSegments[i];
+    const pathSeg = pathSegments[i];
+    if (patternSeg.startsWith(":")) {
+      continue;
+    }
+    if (patternSeg !== pathSeg) {
+      return false;
+    }
+  }
+  return true;
+}
+function generateBreadcrumbSegments(path, options) {
+  const {
+    labels = {},
+    labelGenerator = (s) => formatSegmentLabel(s),
+    includeHome = true,
+    homeLabel = "Home"
+  } = options || {};
+  const segments = [];
+  if (includeHome) {
+    segments.push({ label: labels["/"] || homeLabel, path: "/" });
+  }
+  const parts = path.split("/").filter(Boolean);
+  let cumulativePath = "";
+  for (const part of parts) {
+    cumulativePath += "/" + part;
+    const label = labels[cumulativePath] || labelGenerator(part, cumulativePath);
+    segments.push({ label, path: cumulativePath });
+  }
+  return segments;
+}
+function formatSegmentLabel(segment) {
+  return segment.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function findActiveItemByPath(items, currentPath, mode = "prefix") {
+  const exactMatch = items.find((item) => item.path && matchPath(currentPath, item.path, "exact"));
+  if (exactMatch) return exactMatch.id;
+  if (mode === "prefix") {
+    const sortedItems = [...items].filter((item) => item.path).sort((a, b) => (b.path?.length ?? 0) - (a.path?.length ?? 0));
+    for (const item of sortedItems) {
+      if (item.path && matchPath(currentPath, item.path, "prefix")) {
+        return item.id;
+      }
+    }
+  }
+  return void 0;
+}
+function findActiveItemInSections(sections, currentPath, mode = "prefix") {
+  const allItems = sections.flatMap((s) => s.items);
+  return findActiveItemByPath(allItems, currentPath, mode);
+}
+function joinPath(...segments) {
+  const joined = segments.map((s) => s.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+  return "/" + joined;
+}
+function extractPathParams(path, pattern) {
+  const pathSegments = path.split("/").filter(Boolean);
+  const patternSegments = pattern.split("/").filter(Boolean);
+  if (pathSegments.length !== patternSegments.length) {
+    return null;
+  }
+  const params = {};
+  for (let i = 0; i < patternSegments.length; i++) {
+    const patternSeg = patternSegments[i];
+    const pathSeg = pathSegments[i];
+    if (patternSeg.startsWith(":")) {
+      const paramName = patternSeg.slice(1);
+      params[paramName] = pathSeg;
+    } else if (patternSeg !== pathSeg) {
+      return null;
+    }
+  }
+  return params;
+}
+
+// src/renderers/text.ts
+function renderText(node, options = {}) {
+  const indent = options.indent ?? 0;
+  const indentStr = getIndentStr(indent);
+  const type = node.type;
+  const props = node.props || {};
+  const children = node.children || [];
+  switch (type) {
+    case "text":
+      return renderTextNode(props);
+    case "header":
+      return renderHeader(props);
+    case "list":
+      return renderList(props, children, indent);
+    case "table":
+      return renderTable(props, node.data);
+    case "code":
+      return renderCode(props);
+    case "link":
+      return renderLink(props);
+    case "button":
+      return renderButton(props);
+    case "box":
+      return renderBox(props, children, indent);
+    case "panel":
+      return renderPanel(props, children, indent);
+    case "card":
+      return renderCard(props, children, indent);
+    case "metrics":
+      return renderMetrics(props);
+    case "metric":
+      return renderSingleMetric(props);
+    case "sidebar":
+      return renderSidebar(props, indent);
+    case "breadcrumb":
+      return renderBreadcrumb(props);
+    case "badge":
+      return renderBadge(props);
+    case "dialog":
+      return renderDialog(props, children, indent);
+    case "spinner":
+      return renderSpinner(props);
+    case "dashboard":
+      return renderDashboard(props, children, indent);
+    case "settings":
+      return renderSettings(props, children, indent);
+    case "input":
+      return renderInput(props);
+    case "select":
+      return renderSelect(props);
+    case "hero":
+      return renderHero(props);
+    case "features":
+      return renderFeatures(props);
+    case "pricing":
+      return renderPricing(props);
+    case "faq":
+      return renderFAQ(props);
+    case "footer":
+      return renderFooter(props);
+    default:
+      return renderChildren(children, indent);
+  }
+}
+function renderTextNode(props) {
+  const content = props.content;
+  if (content == null) return "";
+  return String(content);
+}
+function renderHeader(props) {
+  const content = props.content;
+  const nav = props.nav;
+  const callToAction = props.callToAction;
+  const breadcrumbs = props.breadcrumbs;
+  if (content != null) {
+    return String(content);
+  }
+  const parts = [];
+  if (nav && Array.isArray(nav) && nav.length > 0) {
+    const navLabels = nav.map((item) => item.label).join(" | ");
+    parts.push(navLabels);
+  }
+  if (breadcrumbs && Array.isArray(breadcrumbs) && breadcrumbs.length > 0) {
+    const crumbLabels = breadcrumbs.map((item) => item.label).join(" > ");
+    parts.push(crumbLabels);
+  }
+  if (callToAction) {
+    parts.push(callToAction);
+  }
+  return parts.join("\n");
+}
+function renderList(props, children, indent) {
+  const items = props.items;
+  const numbered = getProp(props, "numbered", false);
+  const taskList = getProp(props, "taskList", false);
+  const indentStr = getIndentStr(indent);
+  const lines = [];
+  if (items && Array.isArray(items)) {
+    items.forEach((item, index) => {
+      let text;
+      let prefix;
+      if (typeof item === "string") {
+        text = item;
+        prefix = numbered ? `${index + 1}. ` : "- ";
+      } else if (typeof item === "object" && item !== null) {
+        const itemObj = item;
+        text = itemObj.text ?? String(item);
+        if (taskList && "checked" in itemObj) {
+          prefix = itemObj.checked ? "[x] " : "[ ] ";
+        } else {
+          prefix = numbered ? `${index + 1}. ` : "- ";
+        }
+      } else {
+        text = String(item);
+        prefix = numbered ? `${index + 1}. ` : "- ";
+      }
+      lines.push(`${indentStr}${prefix}${text}`);
+    });
+  }
+  const nestedChildren = children && children.length > 0 ? children : props.children;
+  if (nestedChildren && nestedChildren.length > 0) {
+    nestedChildren.forEach((child, index) => {
+      if (child.type === "list-item") {
+        const content = child.props?.content ?? "";
+        const prefix = numbered ? `${index + 1}. ` : "- ";
+        lines.push(`${indentStr}${prefix}${content}`);
+        if (child.children && child.children.length > 0) {
+          child.children.forEach((nestedChild) => {
+            const nestedOutput = renderText(nestedChild, { indent: indent + 1 });
+            if (nestedOutput) {
+              lines.push(nestedOutput);
+            }
+          });
+        }
+      } else {
+        const childOutput = renderText(child, { indent: indent + 1 });
+        if (childOutput) {
+          lines.push(childOutput);
+        }
+      }
+    });
+  }
+  return lines.join("\n");
+}
+function renderTable(props, nodeData) {
+  const columns = props.columns;
+  const data = nodeData ?? props.data;
+  const lines = [];
+  if (!columns || !Array.isArray(columns)) return "";
+  const headers = extractHeaders(columns);
+  lines.push(headers.join(", "));
+  if (data && Array.isArray(data)) {
+    data.forEach((row) => {
+      const values = extractRowValues(row, columns);
+      lines.push(values.join(", "));
+    });
+  }
+  return lines.join("\n");
+}
+function renderCode(props) {
+  const code = props.code;
+  if (code == null) return "";
+  return String(code);
+}
+function renderLink(props) {
+  const text = props.text;
+  if (text == null) return "";
+  return String(text);
+}
+function renderButton(props) {
+  const label = props.label;
+  const hotkey = props.hotkey;
+  if (!label) return "";
+  if (hotkey) {
+    return `${label} (${hotkey})`;
+  }
+  return label;
+}
+function renderBox(props, children, indent) {
+  const title = props.title;
+  const parts = [];
+  if (title) {
+    parts.push(title);
+  }
+  const childOutput = renderChildren(children, indent);
+  if (childOutput) {
+    parts.push(childOutput);
+  }
+  return parts.join("\n\n");
+}
+function renderPanel(props, children, indent) {
+  const title = props.title;
+  const collapsed = props.collapsed;
+  const parts = [];
+  if (title) {
+    parts.push(title);
+  }
+  const childOutput = renderChildren(children, indent);
+  if (childOutput) {
+    parts.push(childOutput);
+  }
+  return parts.join("\n\n");
+}
+function renderCard(props, children, indent) {
+  const title = props.title;
+  const subtitle = props.subtitle;
+  const badge = props.badge;
+  const titleAction = props.titleAction;
+  const pairs = props.pairs;
+  const actions = props.actions;
+  const parts = [];
+  if (title) {
+    let titleLine = title;
+    if (badge) {
+      titleLine += ` ${badge.content}`;
+    }
+    if (titleAction) {
+      titleLine += ` ${titleAction.label}`;
+    }
+    parts.push(titleLine);
+  }
+  if (subtitle) {
+    parts.push(subtitle);
+  }
+  if (pairs && Array.isArray(pairs)) {
+    const pairLines = pairs.map((p) => {
+      const val = p.value != null ? String(p.value) : "";
+      return `${p.key}: ${val}`;
+    });
+    if (pairLines.length > 0) {
+      parts.push(pairLines.join("\n"));
+    }
+  }
+  const childOutput = renderChildren(children, indent);
+  if (childOutput) {
+    parts.push(childOutput);
+  }
+  if (actions && Array.isArray(actions)) {
+    const actionLabels = actions.map((a) => a.label).join(" | ");
+    if (actionLabels) {
+      parts.push(actionLabels);
+    }
+  }
+  return parts.join("\n\n");
+}
+function renderMetrics(props) {
+  const metrics = props.metrics;
+  if (!metrics || !Array.isArray(metrics) || metrics.length === 0) {
+    return "";
+  }
+  return metrics.map((m) => {
+    const val = m.value != null ? String(m.value) : "";
+    let formatted = val;
+    if (m.format === "percentage" && !val.includes("%")) {
+      formatted = `${val}%`;
+    }
+    if (m.unit) {
+      formatted = `${formatted} ${m.unit}`;
+    }
+    return `${m.label}: ${formatted}`;
+  }).join("\n");
+}
+function renderSingleMetric(props) {
+  const label = props.label;
+  const value = props.value;
+  const format = props.format;
+  const unit = props.unit;
+  if (!label) return "";
+  const val = value != null ? String(value) : "";
+  let formatted = val;
+  if (format === "percentage" && !val.includes("%")) {
+    formatted = `${val}%`;
+  }
+  if (unit) {
+    formatted = `${formatted} ${unit}`;
+  }
+  return `${label}: ${formatted}`;
+}
+function renderSidebar(props, indent) {
+  const nav = props.nav;
+  const sections = props.sections;
+  const lines = [];
+  const indentStr = getIndentStr(indent);
+  if (nav && Array.isArray(nav)) {
+    nav.forEach((item) => {
+      lines.push(`${indentStr}- ${item.label}`);
+      if (item.children && Array.isArray(item.children)) {
+        item.children.forEach((child) => {
+          lines.push(`${indentStr}  - ${child.label}`);
+        });
+      }
+    });
+  }
+  if (sections && Array.isArray(sections)) {
+    sections.forEach((section) => {
+      lines.push(`${indentStr}${section.title}`);
+      if (section.items && Array.isArray(section.items)) {
+        section.items.forEach((item) => {
+          lines.push(`${indentStr}  - ${item.label}`);
+        });
+      }
+    });
+  }
+  return lines.join("\n");
+}
+function renderBreadcrumb(props) {
+  const items = props.items;
+  const separator = props.separator || ">";
+  if (!items || !Array.isArray(items)) return "";
+  return items.map((item) => item.label).join(` ${separator} `);
+}
+function renderBadge(props) {
+  const children = props.children;
+  if (children == null) return "";
+  return String(children);
+}
+function renderDialog(props, children, indent) {
+  const open = props.open;
+  const title = props.title;
+  const actions = props.actions;
+  if (open === false) return "";
+  const parts = [];
+  if (title) {
+    parts.push(title);
+  }
+  const childOutput = renderChildren(children, indent);
+  if (childOutput) {
+    parts.push(childOutput);
+  }
+  if (actions && Array.isArray(actions)) {
+    const actionLabels = actions.map((a) => a.label).join(" | ");
+    parts.push(actionLabels);
+  }
+  return parts.join("\n\n");
+}
+function renderSpinner(props) {
+  const label = props.label;
+  return label || "Loading...";
+}
+function renderDashboard(props, children, indent) {
+  const title = props.title;
+  const metrics = props.metrics;
+  const parts = [];
+  if (title) {
+    parts.push(title);
+  }
+  if (metrics && Array.isArray(metrics) && metrics.length > 0) {
+    const metricsOutput = metrics.map((m) => `${m.label}: ${m.value}`).join("\n");
+    parts.push(metricsOutput);
+  }
+  const childOutput = renderChildren(children, indent);
+  if (childOutput) {
+    parts.push(childOutput);
+  }
+  return parts.join("\n\n");
+}
+function renderSettings(props, children, indent) {
+  const sections = props.sections;
+  const parts = [];
+  if (sections && Array.isArray(sections)) {
+    sections.forEach((section) => {
+      parts.push(section);
+    });
+  }
+  const childOutput = renderChildren(children, indent);
+  if (childOutput) {
+    parts.push(childOutput);
+  }
+  return parts.join("\n");
+}
+function renderInput(props) {
+  const label = props.label;
+  const value = props.value;
+  const placeholder = props.placeholder;
+  const parts = [];
+  if (label) {
+    parts.push(label);
+  }
+  if (value != null) {
+    parts.push(String(value));
+  } else if (placeholder) {
+    parts.push(placeholder);
+  }
+  return parts.join(": ");
+}
+function renderSelect(props) {
+  const label = props.label;
+  const value = props.value;
+  const options = props.options;
+  const parts = [];
+  if (label) {
+    parts.push(label);
+  }
+  if (value && options) {
+    const selected = options.find((o) => o.value === value);
+    if (selected) {
+      parts.push(`Selected: ${selected.label}`);
+    }
+  }
+  if (options && Array.isArray(options)) {
+    options.forEach((opt) => {
+      parts.push(`- ${opt.label}`);
+    });
+  }
+  return parts.join("\n");
+}
+function renderHero(props) {
+  const title = props.title;
+  const subtitle = props.subtitle;
+  const callToAction = props.callToAction;
+  const secondaryCallToAction = props.secondaryCallToAction;
+  const badge = props.badge;
+  const parts = [];
+  if (badge) {
+    parts.push(badge);
+  }
+  if (title) {
+    parts.push(title);
+  }
+  if (subtitle) {
+    parts.push(subtitle);
+  }
+  const ctas = [];
+  if (callToAction) {
+    ctas.push(callToAction);
+  }
+  if (secondaryCallToAction) {
+    ctas.push(secondaryCallToAction);
+  }
+  if (ctas.length > 0) {
+    parts.push(ctas.join(" | "));
+  }
+  return parts.join("\n\n");
+}
+function renderFeatures(props) {
+  const title = props.title;
+  const features = props.features;
+  const parts = [];
+  if (title) {
+    parts.push(title);
+  }
+  if (features && Array.isArray(features)) {
+    features.forEach((feature) => {
+      if (feature.description) {
+        parts.push(`${feature.title}: ${feature.description}`);
+      } else {
+        parts.push(feature.title);
+      }
+    });
+  }
+  return parts.join("\n\n");
+}
+function renderPricing(props) {
+  const tiers = props.tiers;
+  if (!tiers || !Array.isArray(tiers)) return "";
+  const parts = [];
+  tiers.forEach((tier) => {
+    const tierParts = [];
+    tierParts.push(`${tier.name} - ${tier.price}`);
+    if (tier.features && Array.isArray(tier.features)) {
+      tier.features.forEach((feature) => {
+        tierParts.push(`  - ${feature}`);
+      });
+    }
+    if (tier.callToAction) {
+      tierParts.push(`  ${tier.callToAction}`);
+    }
+    parts.push(tierParts.join("\n"));
+  });
+  return parts.join("\n\n");
+}
+function renderFAQ(props) {
+  const title = props.title;
+  const items = props.items;
+  const parts = [];
+  if (title) {
+    parts.push(title);
+  }
+  if (items && Array.isArray(items)) {
+    items.forEach((item) => {
+      parts.push(`Q: ${item.question}`);
+      parts.push(`A: ${item.answer}`);
+    });
+  }
+  return parts.join("\n\n");
+}
+function renderFooter(props) {
+  const links = props.links;
+  const copyright = props.copyright;
+  const social = props.social;
+  const parts = [];
+  if (links && Array.isArray(links)) {
+    links.forEach((section) => {
+      parts.push(section.title);
+      if (section.links && Array.isArray(section.links)) {
+        section.links.forEach((link) => {
+          parts.push(`  - ${link.label}`);
+        });
+      }
+    });
+  }
+  if (social && Array.isArray(social)) {
+    const socialParts = social.map((s) => s.platform).join(" | ");
+    parts.push(socialParts);
+  }
+  if (copyright) {
+    parts.push(copyright);
+  }
+  return parts.join("\n");
+}
+function renderChildren(children, indent) {
+  if (!children || children.length === 0) return "";
+  const parts = [];
+  children.forEach((child) => {
+    const output = renderText(child, { indent });
+    if (output) {
+      parts.push(output);
+    }
+  });
+  return parts.join("\n\n");
+}
+
+// src/renderers/ansi-css.ts
+var FG_16_COLORS = {
+  30: "black",
+  31: "red",
+  32: "green",
+  33: "yellow",
+  34: "blue",
+  35: "magenta",
+  36: "cyan",
+  37: "white"
+};
+var FG_BRIGHT_COLORS = {
+  90: "gray",
+  91: "#ff5555",
+  92: "#55ff55",
+  93: "#ffff55",
+  94: "#5555ff",
+  95: "#ff55ff",
+  96: "#55ffff",
+  97: "#ffffff"
+};
+var BG_16_COLORS = {
+  40: "black",
+  41: "red",
+  42: "green",
+  43: "yellow",
+  44: "blue",
+  45: "magenta",
+  46: "cyan",
+  47: "white"
+};
+var STANDARD_16_HEX = [
+  "#000000",
+  // 0 - black
+  "#800000",
+  // 1 - maroon
+  "#008000",
+  // 2 - green
+  "#808000",
+  // 3 - olive
+  "#000080",
+  // 4 - navy
+  "#800080",
+  // 5 - purple
+  "#008080",
+  // 6 - teal
+  "#c0c0c0",
+  // 7 - silver
+  "#808080",
+  // 8 - gray
+  "#ff0000",
+  // 9 - red
+  "#00ff00",
+  // 10 - lime
+  "#ffff00",
+  // 11 - yellow
+  "#0000ff",
+  // 12 - blue
+  "#ff00ff",
+  // 13 - fuchsia
+  "#00ffff",
+  // 14 - aqua
+  "#ffffff"
+  // 15 - white
+];
+function ansi256ToHex(code) {
+  if (code < 16) {
+    return STANDARD_16_HEX[code];
+  }
+  if (code >= 232) {
+    const gray = (code - 232) * 10 + 8;
+    const hex = gray.toString(16).padStart(2, "0");
+    return `#${hex}${hex}${hex}`;
+  }
+  const cubeIndex = code - 16;
+  const r = Math.floor(cubeIndex / 36);
+  const g = Math.floor(cubeIndex % 36 / 6);
+  const b = cubeIndex % 6;
+  const toValue = (n) => n === 0 ? 0 : 55 + n * 40;
+  const rVal = toValue(r).toString(16).padStart(2, "0");
+  const gVal = toValue(g).toString(16).padStart(2, "0");
+  const bVal = toValue(b).toString(16).padStart(2, "0");
+  return `#${rVal}${gVal}${bVal}`;
+}
+function processSGRCode(code, params, index, state) {
+  if (code === 0) {
+    state.color = void 0;
+    state.backgroundColor = void 0;
+    state.bold = void 0;
+    state.dim = void 0;
+    state.italic = void 0;
+    state.underline = void 0;
+    state.strikethrough = void 0;
+    state.inverse = void 0;
+    return index;
+  }
+  if (code === 1) {
+    state.bold = true;
+    return index;
+  }
+  if (code === 2) {
+    state.dim = true;
+    return index;
+  }
+  if (code === 3) {
+    state.italic = true;
+    return index;
+  }
+  if (code === 4) {
+    state.underline = true;
+    return index;
+  }
+  if (code === 7) {
+    state.inverse = true;
+    return index;
+  }
+  if (code === 9) {
+    state.strikethrough = true;
+    return index;
+  }
+  if (code === 22) {
+    state.bold = false;
+    state.dim = false;
+    return index;
+  }
+  if (code === 23) {
+    state.italic = false;
+    return index;
+  }
+  if (code === 24) {
+    state.underline = false;
+    return index;
+  }
+  if (code >= 30 && code <= 37) {
+    state.color = FG_16_COLORS[code];
+    return index;
+  }
+  if (code === 39) {
+    state.color = void 0;
+    return index;
+  }
+  if (code >= 40 && code <= 47) {
+    state.backgroundColor = BG_16_COLORS[code];
+    return index;
+  }
+  if (code === 49) {
+    state.backgroundColor = void 0;
+    return index;
+  }
+  if (code >= 90 && code <= 97) {
+    state.color = FG_BRIGHT_COLORS[code];
+    return index;
+  }
+  if (code === 38 || code === 48) {
+    const isForeground = code === 38;
+    if (params[index + 1] === 5 && params[index + 2] !== void 0) {
+      const colorCode = params[index + 2];
+      const hexColor = ansi256ToHex(colorCode);
+      if (isForeground) {
+        state.color = hexColor;
+      } else {
+        state.backgroundColor = hexColor;
+      }
+      return index + 2;
+    }
+    if (params[index + 1] === 2 && params[index + 2] !== void 0 && params[index + 3] !== void 0 && params[index + 4] !== void 0) {
+      const r = params[index + 2];
+      const g = params[index + 3];
+      const b = params[index + 4];
+      const rgbColor = `rgb(${r}, ${g}, ${b})`;
+      if (isForeground) {
+        state.color = rgbColor;
+      } else {
+        state.backgroundColor = rgbColor;
+      }
+      return index + 4;
+    }
+  }
+  return index;
+}
+function stateToCSS(state) {
+  const css = {};
+  let fg = state.color;
+  let bg = state.backgroundColor;
+  if (state.inverse) {
+    const tempFg = fg;
+    fg = bg || "inherit";
+    bg = tempFg;
+  }
+  if (fg) {
+    css.color = fg;
+  }
+  if (bg) {
+    css.backgroundColor = bg;
+  }
+  if (state.bold) {
+    css.fontWeight = "bold";
+  } else if (state.bold === false) {
+    css.fontWeight = "normal";
+  }
+  if (state.dim) {
+    css.opacity = 0.5;
+  }
+  if (state.italic) {
+    css.fontStyle = "italic";
+  } else if (state.italic === false) {
+    css.fontStyle = "normal";
+  }
+  if (state.underline) {
+    css.textDecoration = "underline";
+  } else if (state.underline === false) {
+    css.textDecoration = "none";
+  }
+  if (state.strikethrough) {
+    css.textDecoration = "line-through";
+  }
+  return css;
+}
+function cloneState(state) {
+  return { ...state };
+}
+var ANSI_REGEX = /\x1b(?:\[([0-9;]*)([A-Za-z])|\].*?(?:\x1b\\|\x07)|\[[^m]*)/g;
+function parseAnsi(ansiString) {
+  if (!ansiString) {
+    return [];
+  }
+  const spans = [];
+  const state = {};
+  let lastIndex = 0;
+  let match;
+  ANSI_REGEX.lastIndex = 0;
+  while ((match = ANSI_REGEX.exec(ansiString)) !== null) {
+    const textBefore = ansiString.slice(lastIndex, match.index);
+    if (textBefore) {
+      spans.push({
+        text: textBefore,
+        style: stateToCSS(cloneState(state))
+      });
+    }
+    const params = match[1];
+    const terminator = match[2];
+    if (terminator === "m" && params !== void 0) {
+      const codes = params.split(";").filter((p) => p !== "").map((p) => parseInt(p, 10));
+      if (codes.length === 0) {
+        codes.push(0);
+      }
+      let i = 0;
+      while (i < codes.length) {
+        i = processSGRCode(codes[i], codes, i, state) + 1;
+      }
+    }
+    lastIndex = match.index + match[0].length;
+  }
+  const remainingText = ansiString.slice(lastIndex);
+  if (remainingText) {
+    spans.push({
+      text: remainingText,
+      style: stateToCSS(cloneState(state))
+    });
+  }
+  return spans;
+}
+function ansiToCSS(ansiString) {
+  const spans = parseAnsi(ansiString);
+  const plainText = spans.map((s) => s.text).join("");
+  return {
+    spans,
+    plainText
+  };
+}
+function spanToInlineStyle(span) {
+  const parts = [];
+  if (span.style.color) {
+    parts.push(`color: ${span.style.color}`);
+  }
+  if (span.style.backgroundColor) {
+    parts.push(`background-color: ${span.style.backgroundColor}`);
+  }
+  if (span.style.fontWeight) {
+    parts.push(`font-weight: ${span.style.fontWeight}`);
+  }
+  if (span.style.fontStyle) {
+    parts.push(`font-style: ${span.style.fontStyle}`);
+  }
+  if (span.style.textDecoration) {
+    parts.push(`text-decoration: ${span.style.textDecoration}`);
+  }
+  if (span.style.opacity !== void 0) {
+    parts.push(`opacity: ${span.style.opacity}`);
+  }
+  return parts.join("; ");
+}
+function escapeHTML(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function ansiToHTML(ansiString) {
+  if (!ansiString) {
+    return "";
+  }
+  const { spans } = ansiToCSS(ansiString);
+  if (spans.length === 0) {
+    return "";
+  }
+  if (spans.length === 1 && Object.keys(spans[0].style).length === 0) {
+    const text = escapeHTML(spans[0].text);
+    return text.replace(/\n/g, "<br>");
+  }
+  const htmlParts = [];
+  for (const span of spans) {
+    const escapedText = escapeHTML(span.text).replace(/\n/g, "<br>");
+    const styleString = spanToInlineStyle(span);
+    if (styleString) {
+      htmlParts.push(`<span style="${styleString}">${escapedText}</span>`);
+    } else {
+      htmlParts.push(escapedText);
+    }
+  }
+  return htmlParts.join("");
+}
+function parseAnsiToSpans(ansiString) {
+  return parseAnsi(ansiString);
+}
+
+export {
+  getIndentStr,
+  getTextWidth,
+  padText,
+  wrapText,
+  sanitizeToASCII,
+  boxDrawingToASCII,
+  buildBox,
+  extractStringArray,
+  extractHeaders,
+  extractRowValues,
+  joinParts,
+  getProp,
+  DEFAULT_THEME_TOKENS,
+  DEFAULT_RENDER_CONTEXT,
+  ASCII_BOX_CHARS,
+  ASCII_DOUBLE_BOX_CHARS,
+  UNICODE_SINGLE_BOX_CHARS,
+  UNICODE_DOUBLE_BOX_CHARS,
+  UNICODE_ROUNDED_BOX_CHARS,
+  getASCIIBoxChars,
+  getUnicodeBoxChars,
+  UNICODE_SYMBOLS,
+  SPINNER_FRAMES,
+  calculateColumnWidths,
+  buildTableSeparator,
+  buildTableRow,
+  createCallbackRouterAdapter,
+  matchPath,
+  normalizePath,
+  matchPathPattern,
+  generateBreadcrumbSegments,
+  formatSegmentLabel,
+  findActiveItemByPath,
+  findActiveItemInSections,
+  joinPath,
+  extractPathParams,
+  renderText,
+  ansiToCSS,
+  spanToInlineStyle,
+  ansiToHTML,
+  parseAnsiToSpans
+};