tty-table 6.0.1 → 7.0.0

package/dist/mcp.js

@@ -0,0 +1,937 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/breakword/src/main.js
+var require_main = __commonJS({
+  "node_modules/breakword/src/main.js"(exports2, module2) {
+    "use strict";
+    var UNICODE_VERSION = "18.0.0";
+    var WIDE_RANGES = [
+      [4352, 4447],
+      [8986, 8987],
+      [9001, 9002],
+      [9193, 9196],
+      [9200, 9200],
+      [9203, 9203],
+      [9725, 9726],
+      [9748, 9749],
+      [9776, 9783],
+      [9800, 9811],
+      [9855, 9855],
+      [9866, 9871],
+      [9875, 9875],
+      [9889, 9889],
+      [9898, 9899],
+      [9917, 9918],
+      [9924, 9925],
+      [9934, 9934],
+      [9940, 9940],
+      [9962, 9962],
+      [9970, 9971],
+      [9973, 9973],
+      [9978, 9978],
+      [9981, 9981],
+      [9989, 9989],
+      [9994, 9995],
+      [10024, 10024],
+      [10060, 10060],
+      [10062, 10062],
+      [10067, 10069],
+      [10071, 10071],
+      [10133, 10135],
+      [10160, 10160],
+      [10175, 10175],
+      [11035, 11036],
+      [11088, 11088],
+      [11093, 11093],
+      [11904, 11929],
+      [11931, 12019],
+      [12032, 12245],
+      [12272, 12350],
+      [12353, 12438],
+      [12441, 12543],
+      [12549, 12591],
+      [12593, 12686],
+      [12688, 12773],
+      [12783, 12830],
+      [12832, 12871],
+      [12880, 42124],
+      [42128, 42182],
+      [43360, 43388],
+      [44032, 55203],
+      [63744, 64255],
+      [65040, 65049],
+      [65072, 65106],
+      [65108, 65126],
+      [65128, 65131],
+      [65281, 65376],
+      [65504, 65510],
+      [94176, 94180],
+      [94192, 94198],
+      [94208, 101594],
+      [101631, 101664],
+      [101760, 101874],
+      [101888, 102801],
+      [102816, 102866],
+      [110576, 110579],
+      [110581, 110587],
+      [110589, 110590],
+      [110592, 110888],
+      [110898, 110898],
+      [110928, 110930],
+      [110933, 110933],
+      [110948, 110952],
+      [110960, 111355],
+      [119552, 119638],
+      [119648, 119670],
+      [126980, 126980],
+      [127183, 127183],
+      [127374, 127374],
+      [127377, 127386],
+      [127406, 127406],
+      [127488, 127490],
+      [127504, 127547],
+      [127552, 127560],
+      [127568, 127569],
+      [127584, 127589],
+      [127744, 127776],
+      [127789, 127797],
+      [127799, 127868],
+      [127870, 127891],
+      [127904, 127946],
+      [127951, 127955],
+      [127968, 127984],
+      [127988, 127988],
+      [127992, 128062],
+      [128064, 128064],
+      [128066, 128252],
+      [128255, 128317],
+      [128331, 128334],
+      [128336, 128359],
+      [128378, 128378],
+      [128405, 128406],
+      [128420, 128420],
+      [128507, 128591],
+      [128640, 128709],
+      [128716, 128716],
+      [128720, 128722],
+      [128725, 128729],
+      [128732, 128735],
+      [128747, 128748],
+      [128756, 128764],
+      [128986, 128986],
+      [128992, 129003],
+      [129008, 129008],
+      [129292, 129338],
+      [129340, 129349],
+      [129351, 129535],
+      [129648, 129660],
+      [129664, 129734],
+      [129736, 129736],
+      [129740, 129757],
+      [129759, 129771],
+      [129775, 129786],
+      [131072, 196605],
+      [196608, 262141]
+    ];
+    var cell = (cp) => cp <= 65535 ? `\\u${cp.toString(16).toUpperCase().padStart(4, "0")}` : `\\u{${cp.toString(16).toUpperCase()}}`;
+    var WIDE = new RegExp(
+      "[" + WIDE_RANGES.map(([lo, hi]) => cell(lo) + (hi > lo ? `-${cell(hi)}` : "")).join("") + "]",
+      "u"
+    );
+    var ZERO = /[\u200B\p{Mn}\p{Me}\p{Cf}\u1160-\u11FF]/u;
+    var EMOJI = /\p{Emoji_Presentation}/u;
+    function width(char) {
+      if (typeof char !== "string") {
+        throw new TypeError("width() expects a string");
+      }
+      if (char.length === 0) {
+        return 0;
+      }
+      if (char.length > 1 && [...char].length > 1) {
+        throw new TypeError("width() expects exactly one Unicode code point");
+      }
+      const cp = char.codePointAt(0);
+      if (cp < 32 || cp >= 127 && cp < 160) return 0;
+      if (cp === 173) return 1;
+      if (ZERO.test(char)) return 0;
+      if (EMOJI.test(char) && !(cp >= 127462 && cp <= 127487)) return 2;
+      return WIDE.test(char) ? 2 : 1;
+    }
+    module2.exports = function breakword2(input, breakAtLength) {
+      const str = String(input);
+      let indexOfLastFitChar = 0;
+      let fittableLength = 0;
+      let index = 0;
+      for (const char of str) {
+        const currentLength = fittableLength + width(char);
+        if (currentLength > breakAtLength) {
+          break;
+        }
+        indexOfLastFitChar = index;
+        fittableLength = currentLength;
+        index += 1;
+      }
+      return indexOfLastFitChar;
+    };
+    module2.exports.width = width;
+    module2.exports.internals = { UNICODE_VERSION, WIDE_RANGES, WIDE, ZERO, EMOJI, width };
+  }
+});
+
+// src/mcp.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  createMcpServer: () => createMcpServer,
+  handleRenderTable: () => handleRenderTable,
+  renderTableInputSchema: () => renderTableInputSchema
+});
+module.exports = __toCommonJS(mcp_exports);
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_zod = require("zod");
+
+// src/defaults.ts
+var defaults = {
+  borderCharacters: {
+    invisible: [
+      { v: " ", l: " ", j: " ", h: " ", r: " " },
+      { v: " ", l: " ", j: " ", h: " ", r: " " },
+      { v: " ", l: " ", j: " ", h: " ", r: " " }
+    ],
+    solid: [
+      { v: "\u2502", l: "\u250C", j: "\u252C", h: "\u2500", r: "\u2510" },
+      { v: "\u2502", l: "\u251C", j: "\u253C", h: "\u2500", r: "\u2524" },
+      { v: "\u2502", l: "\u2514", j: "\u2534", h: "\u2500", r: "\u2518" }
+    ],
+    dashed: [
+      { v: "|", l: "+", j: "+", h: "-", r: "+" },
+      { v: "|", l: "+", j: "+", h: "-", r: "+" },
+      { v: "|", l: "+", j: "+", h: "-", r: "+" }
+    ],
+    none: [
+      { v: "", l: "", j: "", h: "", r: "" },
+      { v: "", l: "", j: "", h: "", r: "" },
+      { v: "", l: "", j: "", h: "", r: "" }
+    ]
+  },
+  align: "center",
+  borderColor: null,
+  borderStyle: "solid",
+  color: false,
+  COLUMNS: 80,
+  // if !process.stdout.columns assume redirecting to write stream 80 columns is VT200 standard
+  compact: false,
+  defaultErrorValue: "\uFFFD",
+  defaultValue: "",
+  errorOnNull: false,
+  FIXED_WIDTH: false,
+  footerAlign: "center",
+  footerColor: false,
+  formatter: null,
+  headerAlign: "center",
+  headerColor: "yellow",
+  isNull: false,
+  // undocumented cell setting
+  marginLeft: 2,
+  marginTop: 1,
+  paddingBottom: 0,
+  paddingLeft: 1,
+  paddingRight: 1,
+  paddingTop: 0,
+  showHeader: null,
+  // undocumented
+  truncate: false,
+  width: "100%",
+  GUTTER: 1,
+  // undocumented
+  columnSettings: [],
+  // save so cell options can be merged into column options
+  table: {
+    body: "",
+    columnInnerWidths: [],
+    columnWidths: [],
+    columns: [],
+    footer: "",
+    header: "",
+    // post-rendered strings.
+    height: 0,
+    typeLocked: false
+    // once a table type is selected can't switch
+  }
+};
+defaults.borderCharacters["0"] = defaults.borderCharacters.none;
+defaults.borderCharacters["1"] = defaults.borderCharacters.solid;
+defaults.borderCharacters["2"] = defaults.borderCharacters.dashed;
+var defaults_default = defaults;
+
+// src/style.ts
+var import_chalk = __toESM(require("chalk"));
+var import_kleur = __toESM(require("kleur"));
+var import_strip_ansi = __toESM(require("strip-ansi"));
+var colorLib = process && process.stdout ? import_chalk.default : import_kleur.default;
+var style = (str, ...colors) => {
+  const out = colors.reduce(function(input, color) {
+    return colorLib[color](input);
+  }, str);
+  return out;
+};
+var styleEachChar = (str, ...colors) => {
+  const chars = [...(0, import_strip_ansi.default)(str)];
+  const out = chars.reduce((prev, current) => {
+    const coded = colors.reduce((input, color) => {
+      return colorLib[color](input);
+    }, current);
+    return prev + coded;
+  }, "");
+  return out;
+};
+var resetStyle = function(str) {
+  this.configure({ reset: true });
+  return (0, import_strip_ansi.default)(str);
+};
+var colorizeCell = (str, cellOptions, rowType) => {
+  let color = false;
+  switch (true) {
+    case rowType === "body":
+      color = cellOptions.color || color;
+      break;
+    case rowType === "header":
+      color = cellOptions.headerColor || color;
+      break;
+    default:
+      color = cellOptions.footerColor || color;
+  }
+  if (color) {
+    str = style(str, color);
+  }
+  return str;
+};
+var isColorEnabled = () => {
+  return process && process.stdout ? colorLib.level > 0 : colorLib.enabled;
+};
+
+// src/format.ts
+var import_smartwrap = __toESM(require("smartwrap"));
+
+// src/ansi.ts
+var import_breakword = __toESM(require_main());
+var ANSI = /\u001B\[[0-?]*[ -\/]*[@-~]/g;
+var stripAnsi2 = (value) => value.replace(ANSI, "");
+var codePointWidth = (value) => [...value].reduce((total, char) => total + import_breakword.default.width(char), 0);
+var displayWidth = (value) => Math.max(0, ...stripAnsi2(value).split(/\r?\n/).map(codePointWidth));
+
+// src/format.ts
+var addPadding = (config, width) => {
+  return width + config.paddingLeft + config.paddingRight;
+};
+var getDisplayWidth = (value) => {
+  return displayWidth(value.toString());
+};
+var getMaxLength = (columnOptions, rows, columnIndex) => {
+  let widest = 0;
+  if (columnOptions && (columnOptions.value || columnOptions.alias)) {
+    const value = columnOptions.alias || columnOptions.value;
+    widest = getDisplayWidth(value);
+  }
+  for (const row of rows) {
+    if (row[columnIndex]) {
+      const value = row[columnIndex].value ? row[columnIndex].value : row[columnIndex];
+      const width = getDisplayWidth(value);
+      if (width > widest) widest = width;
+    }
+  }
+  return widest;
+};
+var getAvailableWidth = (config) => {
+  if (process && (process.stdout && process.stdout.columns || process.env && process.env.COLUMNS)) {
+    let viewport = process.stdout && process.stdout.columns ? process.stdout.columns : process.env.COLUMNS;
+    viewport = viewport - config.marginLeft;
+    if (config.width !== "auto" && /^\d+%$/.test(config.width)) {
+      return Math.min(1, config.width.slice(0, -1) * 0.01) * viewport;
+    }
+    if (config.width !== "auto" && /^\d+$/.test(config.width)) {
+      config.FIXED_WIDTH = true;
+      return config.width;
+    }
+    return viewport;
+  }
+  if (typeof globalThis.window !== "undefined") return globalThis.window.innerWidth;
+  return config.COLUMNS - config.marginLeft;
+};
+var getStringLength = (str) => {
+  return displayWidth(str);
+};
+var wrapCellText = (config, cellValue, columnIndex, cellOptions, rowType) => {
+  const startAnsiRegexp = /^(\x1b\[[0-9;]*m)+/;
+  const endAnsiRegexp = /(\x1b\[[0-9;]*m)+$/;
+  let str = cellValue.toString();
+  const startMatches = str.match(startAnsiRegexp) || [""];
+  str = str.replace(startAnsiRegexp, "");
+  const endMatches = str.match(endAnsiRegexp) || [""];
+  str = str.replace(endAnsiRegexp, "");
+  let alignTgt;
+  switch (rowType) {
+    case "header":
+      alignTgt = "headerAlign";
+      break;
+    case "body":
+      alignTgt = "align";
+      break;
+    default:
+      alignTgt = "footerAlign";
+  }
+  if (cellOptions[alignTgt] === "center") {
+    cellOptions.paddingLeft = cellOptions.paddingRight = Math.max(
+      cellOptions.paddingRight,
+      cellOptions.paddingLeft,
+      0
+    );
+  }
+  const columnWidth = config.table.columnWidths[columnIndex];
+  const innerWidth = columnWidth - cellOptions.paddingLeft - cellOptions.paddingRight - config.GUTTER;
+  if (typeof config.truncate === "string") {
+    str = truncate(str, cellOptions, innerWidth);
+  } else {
+    str = wrap(str, cellOptions, innerWidth);
+  }
+  const cell = str.split("\n").map((line) => {
+    line = line.trim();
+    const lineLength = getStringLength(line);
+    if (lineLength < columnWidth) {
+      let emptySpace = columnWidth - lineLength;
+      switch (true) {
+        case cellOptions[alignTgt] === "center":
+          emptySpace--;
+          const padBoth = Math.floor(emptySpace / 2);
+          const padRemainder = emptySpace % 2;
+          line = " ".repeat(padBoth) + line + " ".repeat(padBoth + padRemainder);
+          break;
+        case cellOptions[alignTgt] === "right":
+          line = " ".repeat(emptySpace - cellOptions.paddingRight - 1) + line + " ".repeat(cellOptions.paddingRight);
+          break;
+        default:
+          line = " ".repeat(cellOptions.paddingLeft) + line + " ".repeat(emptySpace - cellOptions.paddingLeft - 1);
+      }
+    }
+    return startMatches[0] + line + endMatches[0];
+  });
+  return { cell, innerWidth };
+};
+var truncate = (str, cellOptions, maxWidth) => {
+  const stringWidth = displayWidth(str);
+  if (maxWidth < stringWidth) {
+    str = (0, import_smartwrap.default)(str, {
+      width: maxWidth - displayWidth(cellOptions.truncate),
+      breakword: true
+    }).split("\n")[0];
+    str = str + cellOptions.truncate;
+  }
+  return str;
+};
+var wrap = (str, cellOptions, innerWidth) => {
+  const outstring = (0, import_smartwrap.default)(str, {
+    errorChar: cellOptions.defaultErrorValue,
+    minWidth: 1,
+    trim: true,
+    width: innerWidth
+  });
+  return outstring;
+};
+var getColumnWidths = (config, rows) => {
+  const availableWidth = getAvailableWidth(config);
+  const iterable = config.table.header[0] && config.table.header[0].length > 0 ? config.table.header[0] : rows[0];
+  let widths = iterable.map((column, columnIndex) => {
+    let result;
+    switch (true) {
+      // column width is a percentage of table width specified in column header
+      case (typeof column === "object" && /^\d+%$/.test(column.width)):
+        result = column.width.slice(0, -1) * 0.01 * availableWidth;
+        result = addPadding(config, result);
+        break;
+      // column width is specified in column header
+      case (typeof column === "object" && /^\d+$/.test(column.width)):
+        result = column.width;
+        break;
+      // 'auto' sets column width to its longest value in the initial data set
+      default: {
+        const columnOptions = config.table.header[0][columnIndex] ? config.table.header[0][columnIndex] : {};
+        const measurableRows = rows.length ? rows : config.table.header[0];
+        result = getMaxLength(columnOptions, measurableRows, columnIndex);
+        result = addPadding(config, result);
+      }
+    }
+    result = result + config.GUTTER;
+    return result;
+  });
+  const totalWidth = widths.reduce((prev, current) => prev + current);
+  if (totalWidth > availableWidth || config.FIXED_WIDTH) {
+    const proportion = (availableWidth / totalWidth).toFixed(2) - 0.01;
+    const relativeWidths = widths.map((value) => Math.max(2, Math.floor(proportion * value)));
+    if (config.FIXED_WIDTH) return relativeWidths;
+    if (proportion > 0) {
+      const totalRelativeWidths = relativeWidths.reduce((prev, current) => prev + current);
+      widths = totalRelativeWidths < totalWidth ? relativeWidths : widths;
+    }
+  } else {
+    widths = widths.map(Math.floor);
+  }
+  return widths;
+};
+
+// src/render.ts
+var import_strip_ansi2 = __toESM(require("strip-ansi"));
+var stringifyData = (config, inputData) => {
+  const sections = { header: [], body: [], footer: [] };
+  const marginLeft = " ".repeat(config.marginLeft);
+  const borderStyle = config.borderCharacters[config.borderStyle];
+  const borders = [];
+  const constructorType = getConstructorGeometry(inputData[0] || [], config);
+  const rows = coerceConstructorGeometry(config, inputData, constructorType);
+  if (!global.columnWidths) global.columnWidths = {};
+  if (global.columnWidths[config.tableId]) {
+    config.table.columnWidths = global.columnWidths[config.tableId];
+  } else {
+    const formattedRows = rows.map((row, rowIndex) => {
+      return row.map((cell, cellIndex) => buildCell(config, cell, cellIndex, "body", rowIndex, rows, inputData, true));
+    });
+    global.columnWidths[config.tableId] = config.table.columnWidths = getColumnWidths(config, formattedRows);
+  }
+  switch (true) {
+    case (config.showHeader !== null && !config.showHeader):
+      sections.header = [];
+      break;
+    case config.showHeader === true:
+    case !!config.table.header[0].find((obj) => obj.value || obj.alias):
+      sections.header = config.table.header.map((row) => buildRow(config, row, "header", null, rows, inputData));
+      break;
+    default:
+      sections.header = [];
+  }
+  sections.body = rows.map((row, rowIndex) => buildRow(config, row, "body", rowIndex, rows, inputData));
+  sections.footer = config.table.footer instanceof Array && config.table.footer.length > 0 ? [config.table.footer] : [];
+  sections.footer = sections.footer.map((row) => buildRow(config, row, "footer", null, rows, inputData));
+  for (let a = 0; a < 3; a++) {
+    borders[a] = borderStyle[a].l;
+    config.table.columnWidths.forEach((columnWidth, index, arr) => {
+      borders[a] += borderStyle[a].h.repeat(Math.max(columnWidth, 2) - 1);
+      borders[a] += index + 1 < arr.length ? borderStyle[a].j : "";
+    });
+    borders[a] += borderStyle[a].r;
+    borders[a] = a < 2 ? `${marginLeft + borders[a]}
+` : marginLeft + borders[a];
+  }
+  const output = [borders[0]];
+  for (const [sectionIndex, sectionName] of Object.keys(sections).entries()) {
+    const section = sections[sectionName];
+    for (let rowIndex = 0; rowIndex < section.length; rowIndex++) {
+      const row = section[rowIndex];
+      row.forEach((line) => {
+        output.push(marginLeft + borderStyle[1].v + line.join(borderStyle[1].v) + borderStyle[1].v + "\n");
+      });
+      switch (true) {
+        case (rowIndex === section.length - 1 && sectionIndex === 1 && sections.footer.length === 0):
+          break;
+        case (rowIndex === section.length - 1 && sectionIndex === 2):
+          break;
+        case (config.compact && sectionName === "body" && !row.empty):
+          break;
+        case (config.borderStyle === "none" && config.compact):
+          break;
+        default:
+          output.push(borders[1]);
+      }
+    }
+  }
+  output.push(borders[2]);
+  const finalOutput = "\n".repeat(config.marginTop) + output.join("");
+  config.height = finalOutput.split(/\r\n|\r|\n/).length;
+  return finalOutput;
+};
+var buildRow = (config, row, rowType, rowIndex, rowData, inputData) => {
+  let minRowHeight = 0;
+  if (row.length === 0 && config.compact) {
+    row.empty = true;
+    return row;
+  }
+  const lengthDifference = config.table.columnWidths.length - row.length;
+  if (lengthDifference > 0) row = row.concat(Array.apply(null, new Array(lengthDifference)).map(() => null));
+  else if (lengthDifference < 0) row.length = config.table.columnWidths.length;
+  row = row.map((elem, elemIndex) => {
+    const cell = buildCell(config, elem, elemIndex, rowType, rowIndex, rowData, inputData);
+    minRowHeight = minRowHeight < cell.length ? cell.length : minRowHeight;
+    return cell;
+  });
+  minRowHeight = rowType === "header" ? minRowHeight : minRowHeight + (config.paddingBottom + config.paddingTop);
+  const linedRow = Array.apply(null, { length: minRowHeight }).map(Function.call, () => []);
+  row.forEach(function(cell, a) {
+    const whitespace = " ".repeat(Math.max(config.table.columnWidths[a] - 1, 0));
+    if (rowType === "body") {
+      for (let i = 0; i < config.paddingTop; i++) cell.unshift(whitespace);
+      for (let i = 0; i < config.paddingBottom; i++) cell.push(whitespace);
+    }
+    for (let i = 0; i < minRowHeight; i++) linedRow[i].push(typeof cell[i] !== "undefined" ? cell[i] : whitespace);
+  });
+  return linedRow;
+};
+var buildCell = (config, elem, columnIndex, rowType, rowIndex, rowData, inputData, dryRun = false) => {
+  let cellValue = null;
+  const cellOptions = Object.assign(
+    { reset: false },
+    config,
+    rowType !== "header" ? config.columnSettings[columnIndex] : {},
+    typeof elem === "object" ? elem : {}
+  );
+  if (rowType === "header") {
+    config.table.columns.push(cellOptions);
+    cellValue = cellOptions.alias || cellOptions.value || "";
+  } else {
+    switch (true) {
+      case (typeof elem === "undefined" || elem === null):
+        cellValue = config.errorOnNull ? config.defaultErrorValue : config.defaultValue;
+        if (!isColorEnabled()) cellValue = (0, import_strip_ansi2.default)(cellValue);
+        cellOptions.isNull = true;
+        break;
+      case (typeof elem === "object" && elem !== null && typeof elem.value !== "undefined"):
+        cellValue = elem.value;
+        break;
+      case typeof elem === "function":
+        cellValue = elem.bind({
+          configure: function(object) {
+            return Object.assign(cellOptions, object);
+          },
+          style,
+          resetStyle
+        })(cellValue, columnIndex, rowIndex, rowData, inputData);
+        break;
+      default:
+        cellValue = elem;
+    }
+    if (rowType === "body" && typeof cellOptions.formatter === "function") {
+      cellValue = cellOptions.formatter.bind({
+        configure: function(object) {
+          return Object.assign(cellOptions, object);
+        },
+        style,
+        resetStyle
+      })(cellValue, columnIndex, rowIndex, rowData, inputData);
+    }
+    if (dryRun) return cellValue;
+  }
+  if (!cellOptions.reset) cellValue = colorizeCell(cellValue, cellOptions, rowType);
+  const { cell, innerWidth } = wrapCellText(cellOptions, cellValue, columnIndex, cellOptions, rowType);
+  if (rowType === "header") config.table.columnInnerWidths.push(innerWidth);
+  return cell;
+};
+var getConstructorGeometry = (row, config) => {
+  let type;
+  if (typeof row === "object" && !(row instanceof Array)) {
+    const keys = Object.keys(row);
+    if (config.adapter === "automattic") {
+      const key = keys[0];
+      type = row[key] instanceof Array ? "automattic-cross" : "automattic-vertical";
+    } else type = "o-horizontal";
+  } else type = "a-horizontal";
+  return type;
+};
+var coerceConstructorGeometry = (config, rows, constructorType) => {
+  let output = [];
+  switch (constructorType) {
+    case "automattic-cross":
+      config.columnSettings[0] = config.columnSettings[0] || {};
+      config.columnSettings[0].color = config.headerColor;
+      output = rows.map((obj) => {
+        const key = Object.keys(obj)[0];
+        return [key].concat(obj[key]);
+      });
+      break;
+    case "automattic-vertical":
+      config.columnSettings[0] = config.columnSettings[0] || {};
+      config.columnSettings[0].color = config.headerColor;
+      output = rows.map((value) => {
+        const key = Object.keys(value)[0];
+        return [key, value[key]];
+      });
+      break;
+    case "o-horizontal":
+      if (config.table.header[0].length && config.table.header[0].every((obj) => obj.value)) {
+        output = rows.map((row) => config.table.header[0].map((obj) => row[obj.value]));
+      } else output = rows.map((obj) => Object.values(obj));
+      break;
+    case "a-horizontal":
+      output = rows;
+      break;
+  }
+  return output;
+};
+
+// src/factory.ts
+var counter = 0;
+var Factory = function(paramsArr) {
+  const _configKey = Symbol.config;
+  let header = [];
+  const body = [];
+  let footer = [];
+  let options = {};
+  switch (true) {
+    // header, rows, footer, and options
+    case paramsArr.length === 4:
+      header = paramsArr[0];
+      body.push(...paramsArr[1]);
+      footer = paramsArr[2];
+      options = paramsArr[3];
+      break;
+    // header, rows, footer
+    case (paramsArr.length === 3 && paramsArr[2] instanceof Array):
+      header = paramsArr[0];
+      body.push(...paramsArr[1]);
+      footer = paramsArr[2];
+      break;
+    // header, rows, options
+    case (paramsArr.length === 3 && typeof paramsArr[2] === "object"):
+      header = paramsArr[0];
+      body.push(...paramsArr[1]);
+      options = paramsArr[2];
+      break;
+    // header, rows            (rows, footer is not an option)
+    case (paramsArr.length === 2 && paramsArr[1] instanceof Array):
+      header = paramsArr[0];
+      body.push(...paramsArr[1]);
+      break;
+    // rows, options
+    case (paramsArr.length === 2 && typeof paramsArr[1] === "object"):
+      body.push(...paramsArr[0]);
+      options = paramsArr[1];
+      break;
+    // rows
+    case (paramsArr.length === 1 && paramsArr[0] instanceof Array):
+      body.push(...paramsArr[0]);
+      break;
+    // adapter called: i.e. `require('tty-table')('automattic-cli-table')`
+    case (paramsArr.length === 1 && typeof paramsArr[0] === "string"): {
+      const adapters = {
+        "automattic-cli-table": () => require("../adapters/automattic-cli-table.js"),
+        "default-adapter": () => require("../adapters/default-adapter.js"),
+        "terminal-adapter": () => require("../adapters/terminal-adapter.js")
+      };
+      const load = adapters[paramsArr[0]];
+      if (!load) throw new Error(`Unknown adapter: "${paramsArr[0]}". Available adapters: ${Object.keys(adapters).join(", ")}`);
+      return load();
+    }
+    /* istanbul ignore next */
+    default:
+      console.log("Error: Bad params. \nSee docs at github.com/tecfu/tty-table");
+      process.exit();
+  }
+  const cloneddefaults = JSON.parse(JSON.stringify(defaults_default));
+  const config = Object.assign({}, cloneddefaults, options);
+  config.align = config.alignment || config.align;
+  config.headerAlign = config.headerAlignment || config.headerAlign;
+  if (config.truncate === true) config.truncate = "";
+  if (config.borderColor) {
+    config.borderCharacters[config.borderStyle] = config.borderCharacters[config.borderStyle].map(function(obj) {
+      Object.keys(obj).forEach(function(key) {
+        obj[key] = style(obj[key], config.borderColor);
+      });
+      return obj;
+    });
+  }
+  config.columnSettings = header.slice(0);
+  config.table.header = header;
+  config.table.header = [config.table.header];
+  config.table.footer = footer;
+  if (config.terminalAdapter !== true) {
+    counter++;
+  }
+  config.tableId = counter;
+  const tableObject = Object.create(body);
+  tableObject[_configKey] = config;
+  tableObject.render = function() {
+    const output = stringifyData(this[_configKey], this.slice(0));
+    tableObject.height = this[_configKey].height;
+    return output;
+  };
+  return tableObject;
+};
+var Table = function(...params) {
+  return Factory(params);
+};
+Table.resetStyle = resetStyle;
+Table.style = styleEachChar;
+var factory_default = Table;
+
+// src/index.ts
+var src_default = factory_default;
+
+// package.json
+var package_default = {
+  name: "tty-table",
+  version: "7.0.0",
+  description: "Typed terminal table renderer for Node.js and browsers",
+  main: "dist/index.js",
+  module: "dist/index.mjs",
+  types: "dist/index.d.ts",
+  browser: "dist/browser/tty-table.global.js",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    }
+  },
+  engines: {
+    node: ">=22"
+  },
+  bin: {
+    "tty-table": "adapters/terminal-adapter.js",
+    "tty-table-mcp": "dist/mcp.js"
+  },
+  files: [
+    "dist/",
+    "adapters/",
+    "README.md",
+    "LICENSE.txt"
+  ],
+  scripts: {
+    build: "tsup && tsup --config tsup.browser.config.ts",
+    test: "npx mocha",
+    "test:watch": "vitest",
+    typecheck: "tsc --noEmit",
+    lint: "eslint .",
+    "lint:fix": "eslint . --fix",
+    prepublishOnly: "npm run typecheck && npm run build && npm test && npm run test:unit",
+    "test:unit": "vitest run",
+    "view-examples": "node npm_scripts/run-examples.js view",
+    "save-tests": "node npm_scripts/run-examples.js save"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/tecfu/tty-table.git"
+  },
+  keywords: [
+    "table",
+    "cli-table",
+    "terminal table",
+    "console table",
+    "ascii table"
+  ],
+  author: "Tecfu",
+  license: "MIT",
+  bugs: {
+    url: "https://github.com/tecfu/tty-table/issues"
+  },
+  homepage: "https://github.com/tecfu/tty-table",
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    breakword: "^2.1.0",
+    chalk: "^4.1.2",
+    csv: "^6.3.11",
+    kleur: "^4.1.5",
+    smartwrap: "^4.0.0",
+    "strip-ansi": "^6.0.1",
+    yargs: "^17.7.2",
+    zod: "^4.6.5"
+  },
+  devDependencies: {
+    "@eslint/js": "^9.30.0",
+    "@types/node": "^22.15.0",
+    "@types/yargs": "^17.0.33",
+    chai: "^4.5.0",
+    commander: "^4.1.1",
+    eslint: "^9.30.0",
+    glob: "^13.0.6",
+    mocha: "^12.0.0",
+    tsup: "^8.5.0",
+    typescript: "^5.8.3",
+    "typescript-eslint": "^8.35.0",
+    vitest: "^4.1.11"
+  },
+  defaultTestColumns: 90
+};
+
+// src/mcp.ts
+var headerEntry = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.object({
+    value: import_zod.z.string(),
+    align: import_zod.z.enum(["left", "center", "right"]).optional(),
+    width: import_zod.z.union([import_zod.z.number(), import_zod.z.string()]).optional()
+  })
+]);
+var renderTableInputSchema = {
+  header: import_zod.z.array(headerEntry).optional().describe("Column definitions: names, or {value, align, width} objects"),
+  rows: import_zod.z.array(import_zod.z.union([import_zod.z.array(import_zod.z.unknown()), import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())])).describe("Row data: arrays of cells, or objects keyed by column name"),
+  options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().describe('tty-table options, e.g. {width: 80, borderStyle: "solid"}')
+};
+function handleRenderTable({ header, rows, options }) {
+  try {
+    const opts = options ?? {};
+    const head = header;
+    const table = head?.length ? src_default(head, rows, opts) : src_default(rows, opts);
+    return { content: [{ type: "text", text: table.render() }] };
+  } catch (error) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }]
+    };
+  }
+}
+function createMcpServer() {
+  const server = new import_mcp.McpServer({ name: "tty-table", version: package_default.version });
+  server.registerTool(
+    "render_table",
+    {
+      title: "Render a terminal table",
+      description: "Render data as an ASCII/Unicode terminal table (tty-table). Pass header (column names or {value, align, width} objects), rows (array of arrays, or objects whose keys match the header), and optional options (any tty-table table option, e.g. width, borderStyle, align, compact). Returns the rendered table as text.",
+      inputSchema: renderTableInputSchema
+    },
+    (args) => handleRenderTable(args)
+  );
+  return server;
+}
+var isMain = typeof process !== "undefined" && process.argv[1] && (process.argv[1].endsWith("mcp.js") || process.argv[1].endsWith("mcp.mjs") || process.argv[1].endsWith("mcp.ts") || process.argv[1].includes("tty-table-mcp"));
+if (isMain) {
+  const server = createMcpServer();
+  void server.connect(new import_stdio.StdioServerTransport()).catch((error) => {
+    process.stderr.write(error instanceof Error ? error.stack ?? error.message : String(error));
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMcpServer,
+  handleRenderTable,
+  renderTableInputSchema
+});
+;if (typeof module !== "undefined" && typeof module.exports?.default === "function") { module.exports = Object.assign(module.exports.default, module.exports) }
+//# sourceMappingURL=mcp.js.map