@banumeow/n8n-nodes-oracle-cloud 1.3.7 → 1.3.8

package/node_modules/@langchain/core/node_modules/chalk/source/util.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const stringReplaceAll = (string, substring, replacer) => {
+	let index = string.indexOf(substring);
+	if (index === -1) {
+		return string;
+	}
+
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+
+	returnValue += string.substr(endIndex);
+	return returnValue;
+};
+
+const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		const gotCR = string[index - 1] === '\r';
+		returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
+		endIndex = index + 1;
+		index = string.indexOf('\n', endIndex);
+	} while (index !== -1);
+
+	returnValue += string.substr(endIndex);
+	return returnValue;
+};
+
+module.exports = {
+	stringReplaceAll,
+	stringEncaseCRLFWithFirstIndex
+};

package/node_modules/@langchain/core/node_modules/console-table-printer/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Nahiyan Kamal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@langchain/core/node_modules/console-table-printer/README.md

@@ -0,0 +1,192 @@
+<h1 align="center">console-table-printer</h1>
+
+> 🖥️🍭Printing Pretty Tables on your console</h3>
+
+![NPM Downloads](https://img.shields.io/npm/dw/console-table-printer)
+[![install size](https://packagephobia.com/badge?p=console-table-printer)](https://packagephobia.com/result?p=console-table-printer)
+[![npm version](https://badge.fury.io/js/console-table-printer.svg)](https://badge.fury.io/js/console-table-printer)
+[![codecov](https://codecov.io/gh/console-table-printer/console-table-printer/graph/badge.svg?token=SWX9VBuYUs)](https://codecov.io/gh/console-table-printer/console-table-printer)
+
+## Synopsis
+
+Printing Simple Table with Coloring rows on your console. Its useful when you want to present some tables on console using js.
+
+## Installation
+
+```bash
+npm install console-table-printer --save
+```
+
+## Basic Example
+
+```typescript
+import { printTable } from 'console-table-printer';
+
+// Create a simple task list
+const tasks = [
+  { id: 1, task: 'Fix login bug', priority: 'High', status: 'In Progress' },
+  { id: 2, task: 'Update documentation', priority: 'Medium', status: 'Done' },
+  { id: 3, task: 'Add unit tests', priority: 'High', status: 'Todo' },
+];
+
+// Print the table
+printTable(tasks);
+```
+
+![Screenshot](https://cdn.jsdelivr.net/gh/console-table-printer/console-table-printer@master/static-resources/Example-1-basic.png)
+
+## 🚨🚨Announcement🚨🚨 Official Documentation is moved [Here](https://console-table.netlify.app/docs)
+
+You can also create a Table instance and print it:
+
+```typescript
+import { Table } from 'console-table-printer';
+
+// Create a game leaderboard
+const leaderboard = new Table();
+
+// Add players with their scores
+leaderboard.addRow({ rank: 1, player: 'Alice', score: 1250, level: 'Master' });
+leaderboard.addRow({ rank: 2, player: 'Bob', score: 1180, level: 'Expert' });
+leaderboard.addRows([
+  { rank: 3, player: 'Charlie', score: 1050, level: 'Advanced' },
+  { rank: 4, player: 'Diana', score: 920, level: 'Intermediate' },
+]);
+
+// Print the leaderboard
+leaderboard.printTable();
+```
+
+![Screenshot](https://cdn.jsdelivr.net/gh/console-table-printer/console-table-printer@master/static-resources/Example-2-instance.png)
+
+You can also put some color to your table like this:
+
+```typescript
+import { Table } from 'console-table-printer';
+
+const p = new Table();
+p.addRow({ item: 'Pizza', price: 12.99, rating: '5/5' }, { color: 'red' });
+p.addRow({ item: 'Burger', price: 8.99, rating: '4/5' }, { color: 'green' });
+p.addRow({ item: 'Ramen', price: 15.99, rating: '5/5' }, { color: 'yellow' });
+p.addRow({ item: 'Salad', price: 6.99, rating: '3/5' }, { color: 'cyan' });
+p.printTable();
+```
+
+![Screenshot](https://cdn.jsdelivr.net/gh/console-table-printer/console-table-printer@master/static-resources/Example-3-color.png)
+
+You can also put properties based on columns (color/alignment/title)
+
+```typescript
+import { Table } from 'console-table-printer';
+
+const p = new Table({
+  title: 'Project Status',
+  columns: [
+    { name: 'id', alignment: 'left', color: 'blue' },
+    { name: 'project', alignment: 'left' },
+    { name: 'status', title: 'Current Status' },
+  ],
+  colorMap: {
+    urgent: '\x1b[31m',
+    on_track: '\x1b[32m',
+  },
+});
+
+p.addRow({ id: 1, project: 'Website Redesign', status: 'On Track' }, { color: 'on_track' });
+p.addRow({ id: 2, project: 'Mobile App', status: 'Behind Schedule' }, { color: 'urgent' });
+p.addRow({ id: 3, project: 'API Integration', status: 'Completed' }, { color: 'green' });
+
+p.printTable();
+```
+
+![Screenshot](https://cdn.jsdelivr.net/gh/console-table-printer/console-table-printer@master/static-resources/Example-4-columns.png)
+
+## CLI
+
+There is also a CLI tool for printing Tables on Terminal directly [table-printer-cli](https://www.npmjs.com/package/table-printer-cli)
+
+## Documentation
+
+Official documentation has been moved here: [console-table-documentation](https://console-table.netlify.app)
+
+### Table instance creation
+
+3 ways to Table Instance creation:
+
+1. Simplest way `new Table()`
+
+2. Only with column names: `new Table(['column1', 'column2', 'column3'])`
+
+3. Detailed way of creating table instance
+
+```typescript
+import { Table } from 'console-table-printer';
+
+new Table({
+  title: '📊 Sales Report Q4 2024', // A text showsup on top of table (optional)
+  columns: [
+    { name: 'region', alignment: 'left', color: 'blue' }, // with alignment and color
+    { name: 'sales', alignment: 'right', maxLen: 30 }, // lines bigger than this will be splitted in multiple lines
+    { name: 'growth', title: 'Growth %' }, // Title is what will be shown while printing, by default title = name
+    { name: 'price', transform: (value) => `$${Number(value).toFixed(2)}` }, // Transform function to format cell values before display
+  ],
+  rows: [
+    { region: 'North America', sales: '$2.5M', growth: '+15%' },
+    { region: 'Europe', sales: '$1.8M', growth: '+8%' },
+    { region: 'Asia Pacific', sales: '$3.2M', growth: '+22%' },
+  ],
+  sort: (row1, row2) => row2.sales - row1.sales, // sorting order of rows (optional), this is normal js sort function for Array.sort
+  filter: (row) => row.growth > '+10%', // filtering rows (optional)
+  enabledColumns: ['region', 'sales'], // array of columns that you want to see, all other will be ignored (optional)
+  disabledColumns: ['growth'], // array of columns that you DONT want to see, these will always be hidden
+  colorMap: {
+    high_growth: '\x1b[32m', // define customized color
+  },
+  charLength: {
+    '👋': 2,
+    '😅': 2,
+  }, // custom len of chars in console
+  defaultColumnOptions: {
+    alignment: 'center',
+    color: 'red',
+    maxLen: 40,
+    minLen: 20,
+  },
+});
+```
+
+### Functions
+
+- `addRow(rowObjet, options)` adding single row. This can be chained
+- `addRows(rowObjects, options)` adding multiple rows. array of row object. This case options will be applied to all the objects in row
+- `addColumn(columnObject)` adding single column
+- `addColumns(columnObjects)` adding multiple columns
+- `printTable()` Prints the table on your console
+
+### possible `color` values for rows
+
+Check Docs: [color-vals](https://console-table.netlify.app/docs/doc-color)
+
+Example usage: To Create a row of color blue
+
+```typescript
+table.addRow(rowObject, { color: 'blue' });
+```
+
+Example usage: To apply blue for all rows
+
+```typescript
+table.addRows(rowsArray, { color: 'blue' });
+```
+
+### possible `alignment` values for columns
+
+Check Docs: [alignment-vals](https://console-table.netlify.app/docs/doc-alignment)
+
+### Typescript Support
+
+You can get color / alignment as types. Check Docs: [types-docs](https://console-table.netlify.app/docs/doc-typescript)
+
+## License
+
+[MIT](https://github.com/console-table-printer/console-table-printer/blob/master/LICENSE)

package/node_modules/@langchain/core/node_modules/console-table-printer/dist/index.d.ts

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

package/node_modules/@langchain/core/node_modules/console-table-printer/dist/index.js

@@ -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_1 = __importDefault(require("./src/console-table-printer"));
+exports.Table = console_table_printer_1.default;
+const internal_table_printer_1 = require("./src/internalTable/internal-table-printer");
+Object.defineProperty(exports, "printTable", { enumerable: true, get: function () { return internal_table_printer_1.printSimpleTable; } });
+Object.defineProperty(exports, "renderTable", { enumerable: true, get: function () { return internal_table_printer_1.renderSimpleTable; } });

package/node_modules/@langchain/core/node_modules/console-table-printer/dist/src/console-table-printer.d.ts

@@ -0,0 +1,14 @@
+import TableInternal from './internalTable/internal-table';
+import { Dictionary } from './models/common';
+import { ColumnOptionsRaw, ComplexOptions } from './models/external-table';
+import { RowOptionsRaw } from './utils/table-helpers';
+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/node_modules/@langchain/core/node_modules/console-table-printer/dist/src/console-table-printer.js

@@ -0,0 +1,36 @@
+"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_1 = __importDefault(require("./internalTable/internal-table"));
+const table_helpers_1 = require("./utils/table-helpers");
+class Table {
+    constructor(options) {
+        this.table = new internal_table_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_1.convertRawRowOptionsToStandard)(rowOptions));
+        return this;
+    }
+    addRows(toBeInsertedRows, rowOptions) {
+        this.table.addRows(toBeInsertedRows, (0, table_helpers_1.convertRawRowOptionsToStandard)(rowOptions));
+        return this;
+    }
+    printTable() {
+        const tableRendered = this.table.renderTable();
+        console.log(tableRendered);
+    }
+    render() {
+        return this.table.renderTable();
+    }
+}
+exports.default = Table;

package/node_modules/@langchain/core/node_modules/console-table-printer/dist/src/internalTable/input-converter.d.ts

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

package/node_modules/@langchain/core/node_modules/console-table-printer/dist/src/internalTable/input-converter.js

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

package/node_modules/@langchain/core/node_modules/console-table-printer/dist/src/internalTable/internal-table-printer.d.ts

@@ -0,0 +1,6 @@
+import { Dictionary } from '../models/common';
+import { ComplexOptions } from '../models/external-table';
+import TableInternal from './internal-table';
+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/node_modules/@langchain/core/node_modules/console-table-printer/dist/src/internalTable/internal-table-printer.js

@@ -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_1 = __importDefault(require("../utils/colored-console-line"));
+const string_utils_1 = require("../utils/string-utils");
+const table_constants_1 = require("../utils/table-constants");
+const table_helpers_1 = require("../utils/table-helpers");
+const internal_table_1 = __importDefault(require("./internal-table"));
+const table_pre_processors_1 = require("./table-pre-processors");
+// ║ Index ║         ║        ║
+const renderOneLine = (tableStyle, columns, currentLineIndex, widthLimitedColumnsArray, isHeader, row, colorMap, charLength) => {
+    const line = new colored_console_line_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_1.cellText)(widthLimitedColumnsArray[column.name][currentLineIndex])
+            : '';
+        line.addCharsWithColor(table_constants_1.DEFAULT_ROW_FONT_COLOR, ' ');
+        line.addCharsWithColor((isHeader && table_constants_1.DEFAULT_HEADER_FONT_COLOR) || column.color || row.color, (0, string_utils_1.textWithPadding)(textForThisLine, column.alignment || table_constants_1.DEFAULT_ROW_ALIGNMENT, column.length || table_constants_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_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_1.DEFAULT_COLUMN_LEN)
+            .reduce(reducer, 1);
+    };
+    const titleWithPadding = (0, string_utils_1.textWithPadding)(table.title, table_constants_1.DEFAULT_HEADER_ALIGNMENT, getTableWidth());
+    const styledText = new colored_console_line_1.default(table.colorMap);
+    styledText.addCharsWithColor(table_constants_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_1.renderTableHorizontalBorders)(table.tableStyle.headerTop, table.columns.map((m) => m.length || table_constants_1.DEFAULT_COLUMN_LEN)));
+    // ║ index ║                                  text ║  value ║
+    const row = (0, table_helpers_1.createHeaderAsRow)(table_helpers_1.createRow, table.columns);
+    ret = ret.concat(renderWidthLimitedLines(table.tableStyle, table.columns, row, table.colorMap, true));
+    // ╟═══════╬═══════════════════════════════════════╬════════╢
+    ret.push((0, table_helpers_1.renderTableHorizontalBorders)(table.tableStyle.headerBottom, table.columns.map((m) => m.length || table_constants_1.DEFAULT_COLUMN_LEN)));
+    return ret;
+};
+const renderTableEnding = (table) => {
+    const ret = [];
+    // ╚═══════╩═══════════════════════════════════════╩════════╝
+    ret.push((0, table_helpers_1.renderTableHorizontalBorders)(table.tableStyle.tableBottom, table.columns.map((m) => m.length || table_constants_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_1.renderTableHorizontalBorders)(table.tableStyle.rowSeparator, table.columns.map((m) => m.length || table_constants_1.DEFAULT_COLUMN_LEN)));
+    }
+    return ret;
+};
+const renderTable = (table) => {
+    (0, table_pre_processors_1.preProcessColumns)(table); // enable / disable cols, find maxLn of each col/ computed Columns
+    (0, table_pre_processors_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_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/node_modules/@langchain/core/node_modules/console-table-printer/dist/src/internalTable/internal-table.d.ts

@@ -0,0 +1,31 @@
+import { CharLengthDict, Dictionary, Row } from '../models/common';
+import { ColumnOptionsRaw, ComplexOptions, ComputedColumn, DefaultColumnOptions, RowFilterFunction, RowSortFunction, Valuetransform } from '../models/external-table';
+import { Column, TableStyleDetails } from '../models/internal-table';
+import { ColorMap } from '../utils/colored-console-line';
+import { RowOptions } from '../utils/table-helpers';
+declare class TableInternal {
+    title?: string;
+    tableStyle: TableStyleDetails;
+    columns: Column[];
+    rows: Row[];
+    filterFunction: RowFilterFunction;
+    sortFunction: RowSortFunction;
+    enabledColumns: string[];
+    disabledColumns: string[];
+    computedColumns: ComputedColumn[];
+    rowSeparator: boolean;
+    colorMap: ColorMap;
+    charLength: CharLengthDict;
+    defaultColumnOptions?: DefaultColumnOptions;
+    transforms?: Record<string, Valuetransform>;
+    initSimple(columns: string[]): void;
+    initDetailed(options: ComplexOptions): void;
+    constructor(options?: ComplexOptions | string[]);
+    createColumnFromRow(text: Dictionary): void;
+    addColumn(textOrObj: string | ComputedColumn | ColumnOptionsRaw): void;
+    addColumns(toBeInsertedColumns: string[] | ColumnOptionsRaw[]): void;
+    addRow(text: Dictionary, options?: RowOptions): void;
+    addRows(toBeInsertedRows: Dictionary[], options?: RowOptions): void;
+    renderTable(): string;
+}
+export default TableInternal;

package/node_modules/@langchain/core/node_modules/console-table-printer/dist/src/internalTable/internal-table.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const colored_console_line_1 = require("../utils/colored-console-line");
+const table_constants_1 = require("../utils/table-constants");
+const table_helpers_1 = require("../utils/table-helpers");
+const input_converter_1 = require("./input-converter");
+const internal_table_printer_1 = require("./internal-table-printer");
+const DEFAULT_ROW_SORT_FUNC = () => 0;
+const DEFAULT_ROW_FILTER_FUNC = () => true;
+class TableInternal {
+    initSimple(columns) {
+        this.columns = columns.map((column) => ({
+            name: column,
+            title: column,
+            alignment: table_constants_1.DEFAULT_ROW_ALIGNMENT,
+        }));
+    }
+    initDetailed(options) {
+        var _a;
+        this.title = (options === null || options === void 0 ? void 0 : options.title) || this.title;
+        this.tableStyle = Object.assign(Object.assign({}, this.tableStyle), options === null || options === void 0 ? void 0 : options.style);
+        this.sortFunction = (options === null || options === void 0 ? void 0 : options.sort) || this.sortFunction;
+        this.filterFunction = (options === null || options === void 0 ? void 0 : options.filter) || this.filterFunction;
+        this.enabledColumns = (options === null || options === void 0 ? void 0 : options.enabledColumns) || this.enabledColumns;
+        this.disabledColumns = (options === null || options === void 0 ? void 0 : options.disabledColumns) || this.disabledColumns;
+        this.computedColumns = (options === null || options === void 0 ? void 0 : options.computedColumns) || this.computedColumns;
+        this.columns =
+            ((_a = options === null || options === void 0 ? void 0 : options.columns) === null || _a === void 0 ? void 0 : _a.map((column) => (0, input_converter_1.rawColumnToInternalColumn)(column, options === null || options === void 0 ? void 0 : options.defaultColumnOptions))) || this.columns;
+        this.rowSeparator = (options === null || options === void 0 ? void 0 : options.rowSeparator) || this.rowSeparator;
+        this.charLength = (options === null || options === void 0 ? void 0 : options.charLength) || this.charLength;
+        this.defaultColumnOptions =
+            (options === null || options === void 0 ? void 0 : options.defaultColumnOptions) || this.defaultColumnOptions;
+        if (options === null || options === void 0 ? void 0 : options.shouldDisableColors) {
+            this.colorMap = {};
+        }
+        else if (options === null || options === void 0 ? void 0 : options.colorMap) {
+            this.colorMap = Object.assign(Object.assign({}, this.colorMap), options.colorMap);
+        }
+        if (options.rows !== undefined) {
+            this.addRows(options.rows);
+        }
+    }
+    constructor(options) {
+        // default construction
+        this.rows = [];
+        this.columns = [];
+        this.title = undefined;
+        this.tableStyle = table_constants_1.DEFAULT_TABLE_STYLE;
+        this.filterFunction = DEFAULT_ROW_FILTER_FUNC;
+        this.sortFunction = DEFAULT_ROW_SORT_FUNC;
+        this.enabledColumns = [];
+        this.disabledColumns = [];
+        this.computedColumns = [];
+        this.rowSeparator = table_constants_1.DEFAULT_ROW_SEPARATOR;
+        this.colorMap = colored_console_line_1.DEFAULT_COLOR_MAP;
+        this.charLength = {};
+        this.defaultColumnOptions = undefined;
+        this.transforms = {};
+        if (options instanceof Array) {
+            this.initSimple(options);
+        }
+        else if (typeof options === 'object') {
+            this.initDetailed(options);
+        }
+    }
+    createColumnFromRow(text) {
+        const colNames = this.columns.map((col) => col.name);
+        Object.keys(text).forEach((key) => {
+            if (!colNames.includes(key)) {
+                this.columns.push((0, input_converter_1.rawColumnToInternalColumn)((0, table_helpers_1.createColumFromOnlyName)(key), this.defaultColumnOptions));
+            }
+        });
+    }
+    addColumn(textOrObj) {
+        const columnOptionsFromInput = typeof textOrObj === 'string'
+            ? (0, table_helpers_1.createColumFromOnlyName)(textOrObj)
+            : textOrObj;
+        this.columns.push((0, input_converter_1.rawColumnToInternalColumn)(columnOptionsFromInput, this.defaultColumnOptions));
+    }
+    addColumns(toBeInsertedColumns) {
+        toBeInsertedColumns.forEach((toBeInsertedColumn) => {
+            this.addColumn(toBeInsertedColumn);
+        });
+    }
+    addRow(text, options) {
+        this.createColumnFromRow(text);
+        this.rows.push((0, table_helpers_1.createRow)((options === null || options === void 0 ? void 0 : options.color) || table_constants_1.DEFAULT_ROW_FONT_COLOR, text, (options === null || options === void 0 ? void 0 : options.separator) !== undefined
+            ? options === null || options === void 0 ? void 0 : options.separator
+            : this.rowSeparator));
+    }
+    addRows(toBeInsertedRows, options) {
+        toBeInsertedRows.forEach((toBeInsertedRow) => {
+            this.addRow(toBeInsertedRow, options);
+        });
+    }
+    renderTable() {
+        return (0, internal_table_printer_1.renderTable)(this);
+    }
+}
+exports.default = TableInternal;

package/node_modules/@langchain/core/node_modules/console-table-printer/dist/src/internalTable/table-pre-processors.d.ts

@@ -0,0 +1,3 @@
+import TableInternal from './internal-table';
+export declare const preProcessColumns: (table: TableInternal) => void;
+export declare const preProcessRows: (table: TableInternal) => void;