langsmith 0.5.16 → 0.5.17

package/dist/utils/chalk/source/vendor/supports-color/index.js

@@ -0,0 +1,149 @@
+/* eslint-disable */
+// @ts-nocheck
+import process from 'node:process';
+import os from 'node:os';
+import tty from 'node:tty';
+// From: https://github.com/sindresorhus/has-flag/blob/main/index.js
+/// function hasFlag(flag, argv = globalThis.Deno?.args ?? process.argv) {
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process.argv) {
+    const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+    const position = argv.indexOf(prefix + flag);
+    const terminatorPosition = argv.indexOf('--');
+    return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+const { env } = process;
+let flagForceColor;
+if (hasFlag('no-color')
+    || hasFlag('no-colors')
+    || hasFlag('color=false')
+    || hasFlag('color=never')) {
+    flagForceColor = 0;
+}
+else if (hasFlag('color')
+    || hasFlag('colors')
+    || hasFlag('color=true')
+    || hasFlag('color=always')) {
+    flagForceColor = 1;
+}
+function envForceColor() {
+    if ('FORCE_COLOR' in env) {
+        if (env.FORCE_COLOR === 'true') {
+            return 1;
+        }
+        if (env.FORCE_COLOR === 'false') {
+            return 0;
+        }
+        return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+    }
+}
+function translateLevel(level) {
+    if (level === 0) {
+        return false;
+    }
+    return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3,
+    };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+    const noFlagForceColor = envForceColor();
+    if (noFlagForceColor !== undefined) {
+        flagForceColor = noFlagForceColor;
+    }
+    const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+    if (forceColor === 0) {
+        return 0;
+    }
+    if (sniffFlags) {
+        if (hasFlag('color=16m')
+            || hasFlag('color=full')
+            || hasFlag('color=truecolor')) {
+            return 3;
+        }
+        if (hasFlag('color=256')) {
+            return 2;
+        }
+    }
+    // Check for Azure DevOps pipelines.
+    // Has to be above the `!streamIsTTY` check.
+    if ('TF_BUILD' in env && 'AGENT_NAME' in env) {
+        return 1;
+    }
+    if (haveStream && !streamIsTTY && forceColor === undefined) {
+        return 0;
+    }
+    const min = forceColor || 0;
+    if (env.TERM === 'dumb') {
+        return min;
+    }
+    if (process.platform === 'win32') {
+        // Windows 10 build 10586 is the first Windows release that supports 256 colors.
+        // Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+        const osRelease = os.release().split('.');
+        if (Number(osRelease[0]) >= 10
+            && Number(osRelease[2]) >= 10_586) {
+            return Number(osRelease[2]) >= 14_931 ? 3 : 2;
+        }
+        return 1;
+    }
+    if ('CI' in env) {
+        if (['GITHUB_ACTIONS', 'GITEA_ACTIONS', 'CIRCLECI'].some(key => key in env)) {
+            return 3;
+        }
+        if (['TRAVIS', 'APPVEYOR', 'GITLAB_CI', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+            return 1;
+        }
+        return min;
+    }
+    if ('TEAMCITY_VERSION' in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+    }
+    if (env.COLORTERM === 'truecolor') {
+        return 3;
+    }
+    if (env.TERM === 'xterm-kitty') {
+        return 3;
+    }
+    if (env.TERM === 'xterm-ghostty') {
+        return 3;
+    }
+    if (env.TERM === 'wezterm') {
+        return 3;
+    }
+    if ('TERM_PROGRAM' in env) {
+        const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+        switch (env.TERM_PROGRAM) {
+            case 'iTerm.app': {
+                return version >= 3 ? 3 : 2;
+            }
+            case 'Apple_Terminal': {
+                return 2;
+            }
+            // No default
+        }
+    }
+    if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+    }
+    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+    }
+    if ('COLORTERM' in env) {
+        return 1;
+    }
+    return min;
+}
+export function createSupportsColor(stream, options = {}) {
+    const level = _supportsColor(stream, {
+        streamIsTTY: stream && stream.isTTY,
+        ...options,
+    });
+    return translateLevel(level);
+}
+const supportsColor = {
+    stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+    stderr: createSupportsColor({ isTTY: tty.isatty(2) }),
+};
+export default supportsColor;

package/dist/utils/console-table-printer/index.cjs

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTable = exports.printTable = exports.Table = void 0;
+const console_table_printer_js_1 = __importDefault(require("./src/console-table-printer.cjs"));
+exports.Table = console_table_printer_js_1.default;
+const internal_table_printer_js_1 = require("./src/internalTable/internal-table-printer.cjs");
+Object.defineProperty(exports, "printTable", { enumerable: true, get: function () { return internal_table_printer_js_1.printSimpleTable; } });
+Object.defineProperty(exports, "renderTable", { enumerable: true, get: function () { return internal_table_printer_js_1.renderSimpleTable; } });

package/dist/utils/console-table-printer/index.d.ts

@@ -0,0 +1,4 @@
+import Table from './src/console-table-printer.js';
+import { printSimpleTable as printTable, renderSimpleTable as renderTable } from './src/internalTable/internal-table-printer.js';
+import { COLOR, ALIGNMENT } from './src/models/external-table.js';
+export { Table, printTable, renderTable, COLOR, ALIGNMENT };

package/dist/utils/console-table-printer/index.js

@@ -0,0 +1,3 @@
+import Table from './src/console-table-printer.js';
+import { printSimpleTable as printTable, renderSimpleTable as renderTable, } from './src/internalTable/internal-table-printer.js';
+export { Table, printTable, renderTable };

package/dist/utils/console-table-printer/src/console-table-printer.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const internal_table_js_1 = __importDefault(require("./internalTable/internal-table.cjs"));
+const table_helpers_js_1 = require("./utils/table-helpers.cjs");
+class Table {
+    constructor(options) {
+        Object.defineProperty(this, "table", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.table = new internal_table_js_1.default(options);
+    }
+    addColumn(column) {
+        this.table.addColumn(column);
+        return this;
+    }
+    addColumns(columns) {
+        this.table.addColumns(columns);
+        return this;
+    }
+    addRow(text, rowOptions) {
+        this.table.addRow(text, (0, table_helpers_js_1.convertRawRowOptionsToStandard)(rowOptions));
+        return this;
+    }
+    addRows(toBeInsertedRows, rowOptions) {
+        this.table.addRows(toBeInsertedRows, (0, table_helpers_js_1.convertRawRowOptionsToStandard)(rowOptions));
+        return this;
+    }
+    printTable() {
+        const tableRendered = this.table.renderTable();
+        console.log(tableRendered);
+    }
+    render() {
+        return this.table.renderTable();
+    }
+}
+exports.default = Table;

package/dist/utils/console-table-printer/src/console-table-printer.d.ts

@@ -0,0 +1,14 @@
+import TableInternal from './internalTable/internal-table.js';
+import { Dictionary } from './models/common.js';
+import { ColumnOptionsRaw, ComplexOptions } from './models/external-table.js';
+import { RowOptionsRaw } from './utils/table-helpers.js';
+export default class Table {
+    table: TableInternal;
+    constructor(options?: ComplexOptions | string[]);
+    addColumn(column: string | ColumnOptionsRaw): this;
+    addColumns(columns: string[] | ColumnOptionsRaw[]): this;
+    addRow(text: Dictionary, rowOptions?: RowOptionsRaw): this;
+    addRows(toBeInsertedRows: Dictionary[], rowOptions?: RowOptionsRaw): this;
+    printTable(): void;
+    render(): string;
+}

package/dist/utils/console-table-printer/src/console-table-printer.js

@@ -0,0 +1,36 @@
+import TableInternal from './internalTable/internal-table.js';
+import { convertRawRowOptionsToStandard, } from './utils/table-helpers.js';
+export default class Table {
+    constructor(options) {
+        Object.defineProperty(this, "table", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.table = new TableInternal(options);
+    }
+    addColumn(column) {
+        this.table.addColumn(column);
+        return this;
+    }
+    addColumns(columns) {
+        this.table.addColumns(columns);
+        return this;
+    }
+    addRow(text, rowOptions) {
+        this.table.addRow(text, convertRawRowOptionsToStandard(rowOptions));
+        return this;
+    }
+    addRows(toBeInsertedRows, rowOptions) {
+        this.table.addRows(toBeInsertedRows, convertRawRowOptionsToStandard(rowOptions));
+        return this;
+    }
+    printTable() {
+        const tableRendered = this.table.renderTable();
+        console.log(tableRendered);
+    }
+    render() {
+        return this.table.renderTable();
+    }
+}

package/dist/utils/console-table-printer/src/internalTable/input-converter.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawColumnToInternalColumn = exports.objIfExists = void 0;
+const table_constants_js_1 = require("../utils/table-constants.cjs");
+const objIfExists = (key, val) => {
+    if (!val) {
+        return {};
+    }
+    return {
+        [key]: val,
+    };
+};
+exports.objIfExists = objIfExists;
+const rawColumnToInternalColumn = (column, defaultColumnStyles) => ({
+    name: column.name,
+    title: column.title ?? column.name,
+    ...(0, exports.objIfExists)('color', (column.color || defaultColumnStyles?.color)),
+    ...(0, exports.objIfExists)('maxLen', (column.maxLen || defaultColumnStyles?.maxLen)),
+    ...(0, exports.objIfExists)('minLen', (column.minLen || defaultColumnStyles?.minLen)),
+    alignment: (column.alignment ||
+        defaultColumnStyles?.alignment ||
+        table_constants_js_1.DEFAULT_ROW_ALIGNMENT),
+    transform: column.transform,
+});
+exports.rawColumnToInternalColumn = rawColumnToInternalColumn;

package/dist/utils/console-table-printer/src/internalTable/input-converter.d.ts

@@ -0,0 +1,6 @@
+import { ColumnOptionsRaw, ComputedColumn, DefaultColumnOptions } from '../models/external-table.js';
+import { Column } from '../models/internal-table.js';
+export declare const objIfExists: (key: string, val: any) => {
+    [x: string]: any;
+};
+export declare const rawColumnToInternalColumn: (column: ColumnOptionsRaw | ComputedColumn, defaultColumnStyles?: DefaultColumnOptions) => Column;

package/dist/utils/console-table-printer/src/internalTable/input-converter.js

@@ -0,0 +1,20 @@
+import { DEFAULT_ROW_ALIGNMENT } from '../utils/table-constants.js';
+export const objIfExists = (key, val) => {
+    if (!val) {
+        return {};
+    }
+    return {
+        [key]: val,
+    };
+};
+export const rawColumnToInternalColumn = (column, defaultColumnStyles) => ({
+    name: column.name,
+    title: column.title ?? column.name,
+    ...objIfExists('color', (column.color || defaultColumnStyles?.color)),
+    ...objIfExists('maxLen', (column.maxLen || defaultColumnStyles?.maxLen)),
+    ...objIfExists('minLen', (column.minLen || defaultColumnStyles?.minLen)),
+    alignment: (column.alignment ||
+        defaultColumnStyles?.alignment ||
+        DEFAULT_ROW_ALIGNMENT),
+    transform: column.transform,
+});

package/dist/utils/console-table-printer/src/internalTable/internal-table-printer.cjs

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printSimpleTable = exports.renderSimpleTable = exports.renderTable = void 0;
+const colored_console_line_js_1 = __importDefault(require("../utils/colored-console-line.cjs"));
+const string_utils_js_1 = require("../utils/string-utils.cjs");
+const table_constants_js_1 = require("../utils/table-constants.cjs");
+const table_helpers_js_1 = require("../utils/table-helpers.cjs");
+const internal_table_js_1 = __importDefault(require("./internal-table.cjs"));
+const table_pre_processors_js_1 = require("./table-pre-processors.cjs");
+// ║ Index ║         ║        ║
+const renderOneLine = (tableStyle, columns, currentLineIndex, widthLimitedColumnsArray, isHeader, row, colorMap, charLength) => {
+    const line = new colored_console_line_js_1.default(colorMap);
+    line.addCharsWithColor('', tableStyle.vertical); // dont Color the Column borders
+    columns.forEach((column) => {
+        const thisLineHasText = currentLineIndex < widthLimitedColumnsArray[column.name].length;
+        const textForThisLine = thisLineHasText
+            ? (0, table_helpers_js_1.cellText)(widthLimitedColumnsArray[column.name][currentLineIndex])
+            : '';
+        line.addCharsWithColor(table_constants_js_1.DEFAULT_ROW_FONT_COLOR, ' ');
+        line.addCharsWithColor((isHeader && table_constants_js_1.DEFAULT_HEADER_FONT_COLOR) || column.color || row.color, (0, string_utils_js_1.textWithPadding)(textForThisLine, column.alignment || table_constants_js_1.DEFAULT_ROW_ALIGNMENT, column.length || table_constants_js_1.DEFAULT_COLUMN_LEN, charLength));
+        line.addCharsWithColor('', ` ${tableStyle.vertical}`); // dont Color the Column borders
+    });
+    return line.renderConsole();
+};
+// ║ Bold  ║    text ║  value ║
+// ║ Index ║         ║        ║
+const renderWidthLimitedLines = (tableStyle, columns, row, colorMap, isHeader, charLength) => {
+    // { col1: ['How', 'Is', 'Going'], col2: ['I am', 'Tom'],  }
+    const widthLimitedColumnsArray = (0, table_helpers_js_1.getWidthLimitedColumnsArray)(columns, row, charLength);
+    const totalLines = Object.values(widthLimitedColumnsArray).reduce((a, b) => Math.max(a, b.length), 0);
+    const ret = [];
+    for (let currentLineIndex = 0; currentLineIndex < totalLines; currentLineIndex += 1) {
+        const singleLine = renderOneLine(tableStyle, columns, currentLineIndex, widthLimitedColumnsArray, isHeader, row, colorMap, charLength);
+        ret.push(singleLine);
+    }
+    return ret;
+};
+const transformRow = (row, columns) => {
+    const transformedRow = JSON.parse(JSON.stringify(row));
+    const transforms = {};
+    columns
+        .filter((c) => {
+        return !!c.transform;
+    })
+        .forEach((c) => {
+        transforms[c.name] = c.transform;
+    });
+    Object.keys(transforms).forEach((t) => {
+        transformedRow.text[t] = transforms[t](transformedRow.text[t]);
+    });
+    return transformedRow;
+};
+// ║ 1     ║     I would like some red wine please ║ 10.212 ║
+const renderRow = (table, row) => {
+    let ret = [];
+    const transformedRow = transformRow(row, table.columns);
+    ret = ret.concat(renderWidthLimitedLines(table.tableStyle, table.columns, transformedRow, table.colorMap, undefined, table.charLength));
+    return ret;
+};
+/*
+                  The analysis Result
+ ╔═══════╦═══════════════════════════════════════╦════════╗
+*/
+const renderTableTitle = (table) => {
+    const ret = [];
+    if (table.title === undefined) {
+        return ret;
+    }
+    const getTableWidth = () => {
+        const reducer = (accumulator, currentValue) => 
+        // ║ cell ║, 2 spaces + cellTextSize + one border on the left
+        accumulator + currentValue + 2 + 1;
+        return table.columns
+            .map((m) => m.length || table_constants_js_1.DEFAULT_COLUMN_LEN)
+            .reduce(reducer, 1);
+    };
+    const titleWithPadding = (0, string_utils_js_1.textWithPadding)(table.title, table_constants_js_1.DEFAULT_HEADER_ALIGNMENT, getTableWidth());
+    const styledText = new colored_console_line_js_1.default(table.colorMap);
+    styledText.addCharsWithColor(table_constants_js_1.DEFAULT_HEADER_FONT_COLOR, titleWithPadding);
+    //                  The analysis Result
+    ret.push(styledText.renderConsole());
+    return ret;
+};
+/*
+ ╔═══════╦═══════════════════════════════════════╦════════╗
+ ║ index ║                                  text ║  value ║
+ ╟═══════╬═══════════════════════════════════════╬════════╢
+*/
+const renderTableHeaders = (table) => {
+    let ret = [];
+    // ╔═══════╦═══════════════════════════════════════╦════════╗
+    ret.push((0, table_helpers_js_1.renderTableHorizontalBorders)(table.tableStyle.headerTop, table.columns.map((m) => m.length || table_constants_js_1.DEFAULT_COLUMN_LEN)));
+    // ║ index ║                                  text ║  value ║
+    const row = (0, table_helpers_js_1.createHeaderAsRow)(table_helpers_js_1.createRow, table.columns);
+    ret = ret.concat(renderWidthLimitedLines(table.tableStyle, table.columns, row, table.colorMap, true));
+    // ╟═══════╬═══════════════════════════════════════╬════════╢
+    ret.push((0, table_helpers_js_1.renderTableHorizontalBorders)(table.tableStyle.headerBottom, table.columns.map((m) => m.length || table_constants_js_1.DEFAULT_COLUMN_LEN)));
+    return ret;
+};
+const renderTableEnding = (table) => {
+    const ret = [];
+    // ╚═══════╩═══════════════════════════════════════╩════════╝
+    ret.push((0, table_helpers_js_1.renderTableHorizontalBorders)(table.tableStyle.tableBottom, table.columns.map((m) => m.length || table_constants_js_1.DEFAULT_COLUMN_LEN)));
+    return ret;
+};
+const renderRowSeparator = (table, row) => {
+    const ret = [];
+    const lastRowIndex = table.rows.length - 1;
+    const currentRowIndex = table.rows.indexOf(row);
+    if (currentRowIndex !== lastRowIndex && row.separator) {
+        // ╟═══════╬═══════════════════════════════════════╬════════╢
+        ret.push((0, table_helpers_js_1.renderTableHorizontalBorders)(table.tableStyle.rowSeparator, table.columns.map((m) => m.length || table_constants_js_1.DEFAULT_COLUMN_LEN)));
+    }
+    return ret;
+};
+const renderTable = (table) => {
+    (0, table_pre_processors_js_1.preProcessColumns)(table); // enable / disable cols, find maxLn of each col/ computed Columns
+    (0, table_pre_processors_js_1.preProcessRows)(table); // sort and filter
+    const ret = [];
+    renderTableTitle(table).forEach((row) => ret.push(row));
+    renderTableHeaders(table).forEach((row) => ret.push(row));
+    table.rows.forEach((row) => {
+        renderRow(table, row).forEach((row_) => ret.push(row_));
+        renderRowSeparator(table, row).forEach((row_) => ret.push(row_));
+    });
+    renderTableEnding(table).forEach((row) => ret.push(row));
+    return ret.join('\n');
+};
+exports.renderTable = renderTable;
+const renderSimpleTable = (rows, tableOptions) => {
+    const table = new internal_table_js_1.default(tableOptions);
+    table.addRows(rows);
+    return (0, exports.renderTable)(table);
+};
+exports.renderSimpleTable = renderSimpleTable;
+const printSimpleTable = (rows, tableOptions) => {
+    console.log((0, exports.renderSimpleTable)(rows, tableOptions));
+};
+exports.printSimpleTable = printSimpleTable;

package/dist/utils/console-table-printer/src/internalTable/internal-table-printer.d.ts

@@ -0,0 +1,6 @@
+import { Dictionary } from '../models/common.js';
+import { ComplexOptions } from '../models/external-table.js';
+import TableInternal from './internal-table.js';
+export declare const renderTable: (table: TableInternal) => string;
+export declare const renderSimpleTable: (rows: Dictionary[], tableOptions?: ComplexOptions) => string;
+export declare const printSimpleTable: (rows: Dictionary[], tableOptions?: ComplexOptions) => void;

package/dist/utils/console-table-printer/src/internalTable/internal-table-printer.js

@@ -0,0 +1,133 @@
+import ColoredConsoleLine from '../utils/colored-console-line.js';
+import { textWithPadding } from '../utils/string-utils.js';
+import { DEFAULT_COLUMN_LEN, DEFAULT_HEADER_ALIGNMENT, DEFAULT_HEADER_FONT_COLOR, DEFAULT_ROW_ALIGNMENT, DEFAULT_ROW_FONT_COLOR, } from '../utils/table-constants.js';
+import { cellText, createHeaderAsRow, createRow, getWidthLimitedColumnsArray, renderTableHorizontalBorders, } from '../utils/table-helpers.js';
+import TableInternal from './internal-table.js';
+import { preProcessColumns, preProcessRows } from './table-pre-processors.js';
+// ║ Index ║         ║        ║
+const renderOneLine = (tableStyle, columns, currentLineIndex, widthLimitedColumnsArray, isHeader, row, colorMap, charLength) => {
+    const line = new ColoredConsoleLine(colorMap);
+    line.addCharsWithColor('', tableStyle.vertical); // dont Color the Column borders
+    columns.forEach((column) => {
+        const thisLineHasText = currentLineIndex < widthLimitedColumnsArray[column.name].length;
+        const textForThisLine = thisLineHasText
+            ? cellText(widthLimitedColumnsArray[column.name][currentLineIndex])
+            : '';
+        line.addCharsWithColor(DEFAULT_ROW_FONT_COLOR, ' ');
+        line.addCharsWithColor((isHeader && DEFAULT_HEADER_FONT_COLOR) || column.color || row.color, textWithPadding(textForThisLine, column.alignment || DEFAULT_ROW_ALIGNMENT, column.length || DEFAULT_COLUMN_LEN, charLength));
+        line.addCharsWithColor('', ` ${tableStyle.vertical}`); // dont Color the Column borders
+    });
+    return line.renderConsole();
+};
+// ║ Bold  ║    text ║  value ║
+// ║ Index ║         ║        ║
+const renderWidthLimitedLines = (tableStyle, columns, row, colorMap, isHeader, charLength) => {
+    // { col1: ['How', 'Is', 'Going'], col2: ['I am', 'Tom'],  }
+    const widthLimitedColumnsArray = getWidthLimitedColumnsArray(columns, row, charLength);
+    const totalLines = Object.values(widthLimitedColumnsArray).reduce((a, b) => Math.max(a, b.length), 0);
+    const ret = [];
+    for (let currentLineIndex = 0; currentLineIndex < totalLines; currentLineIndex += 1) {
+        const singleLine = renderOneLine(tableStyle, columns, currentLineIndex, widthLimitedColumnsArray, isHeader, row, colorMap, charLength);
+        ret.push(singleLine);
+    }
+    return ret;
+};
+const transformRow = (row, columns) => {
+    const transformedRow = JSON.parse(JSON.stringify(row));
+    const transforms = {};
+    columns
+        .filter((c) => {
+        return !!c.transform;
+    })
+        .forEach((c) => {
+        transforms[c.name] = c.transform;
+    });
+    Object.keys(transforms).forEach((t) => {
+        transformedRow.text[t] = transforms[t](transformedRow.text[t]);
+    });
+    return transformedRow;
+};
+// ║ 1     ║     I would like some red wine please ║ 10.212 ║
+const renderRow = (table, row) => {
+    let ret = [];
+    const transformedRow = transformRow(row, table.columns);
+    ret = ret.concat(renderWidthLimitedLines(table.tableStyle, table.columns, transformedRow, table.colorMap, undefined, table.charLength));
+    return ret;
+};
+/*
+                  The analysis Result
+ ╔═══════╦═══════════════════════════════════════╦════════╗
+*/
+const renderTableTitle = (table) => {
+    const ret = [];
+    if (table.title === undefined) {
+        return ret;
+    }
+    const getTableWidth = () => {
+        const reducer = (accumulator, currentValue) => 
+        // ║ cell ║, 2 spaces + cellTextSize + one border on the left
+        accumulator + currentValue + 2 + 1;
+        return table.columns
+            .map((m) => m.length || DEFAULT_COLUMN_LEN)
+            .reduce(reducer, 1);
+    };
+    const titleWithPadding = textWithPadding(table.title, DEFAULT_HEADER_ALIGNMENT, getTableWidth());
+    const styledText = new ColoredConsoleLine(table.colorMap);
+    styledText.addCharsWithColor(DEFAULT_HEADER_FONT_COLOR, titleWithPadding);
+    //                  The analysis Result
+    ret.push(styledText.renderConsole());
+    return ret;
+};
+/*
+ ╔═══════╦═══════════════════════════════════════╦════════╗
+ ║ index ║                                  text ║  value ║
+ ╟═══════╬═══════════════════════════════════════╬════════╢
+*/
+const renderTableHeaders = (table) => {
+    let ret = [];
+    // ╔═══════╦═══════════════════════════════════════╦════════╗
+    ret.push(renderTableHorizontalBorders(table.tableStyle.headerTop, table.columns.map((m) => m.length || DEFAULT_COLUMN_LEN)));
+    // ║ index ║                                  text ║  value ║
+    const row = createHeaderAsRow(createRow, table.columns);
+    ret = ret.concat(renderWidthLimitedLines(table.tableStyle, table.columns, row, table.colorMap, true));
+    // ╟═══════╬═══════════════════════════════════════╬════════╢
+    ret.push(renderTableHorizontalBorders(table.tableStyle.headerBottom, table.columns.map((m) => m.length || DEFAULT_COLUMN_LEN)));
+    return ret;
+};
+const renderTableEnding = (table) => {
+    const ret = [];
+    // ╚═══════╩═══════════════════════════════════════╩════════╝
+    ret.push(renderTableHorizontalBorders(table.tableStyle.tableBottom, table.columns.map((m) => m.length || DEFAULT_COLUMN_LEN)));
+    return ret;
+};
+const renderRowSeparator = (table, row) => {
+    const ret = [];
+    const lastRowIndex = table.rows.length - 1;
+    const currentRowIndex = table.rows.indexOf(row);
+    if (currentRowIndex !== lastRowIndex && row.separator) {
+        // ╟═══════╬═══════════════════════════════════════╬════════╢
+        ret.push(renderTableHorizontalBorders(table.tableStyle.rowSeparator, table.columns.map((m) => m.length || DEFAULT_COLUMN_LEN)));
+    }
+    return ret;
+};
+export const renderTable = (table) => {
+    preProcessColumns(table); // enable / disable cols, find maxLn of each col/ computed Columns
+    preProcessRows(table); // sort and filter
+    const ret = [];
+    renderTableTitle(table).forEach((row) => ret.push(row));
+    renderTableHeaders(table).forEach((row) => ret.push(row));
+    table.rows.forEach((row) => {
+        renderRow(table, row).forEach((row_) => ret.push(row_));
+        renderRowSeparator(table, row).forEach((row_) => ret.push(row_));
+    });
+    renderTableEnding(table).forEach((row) => ret.push(row));
+    return ret.join('\n');
+};
+export const renderSimpleTable = (rows, tableOptions) => {
+    const table = new TableInternal(tableOptions);
+    table.addRows(rows);
+    return renderTable(table);
+};
+export const printSimpleTable = (rows, tableOptions) => {
+    console.log(renderSimpleTable(rows, tableOptions));
+};