diff --git a/lib/node_modules/@stdlib/plot/table/unicode/README.md b/lib/node_modules/@stdlib/plot/table/unicode/README.md
new file mode 100644
index 000000000000..4edd1d82c108
--- /dev/null
+++ b/lib/node_modules/@stdlib/plot/table/unicode/README.md
@@ -0,0 +1,1162 @@
+
+
+# Unicode Table
+
+> Create a Unicode table.
+
+
+
+## Usage
+
+```javascript
+var UnicodeTable = require( '@stdlib/plot/table/unicode' );
+```
+
+#### UnicodeTable( \[data,] \[options] )
+
+Returns a table instance.
+
+```javascript
+var table = new UnicodeTable();
+```
+
+The constructor accepts the following arguments:
+
+- **data**: table data provided as either an object, an array of objects, an array of arrays, or a two-dimensional [ndarray][@stdlib/ndarray/ctor] (_optional_).
+- **options**: constructor options (_optional_).
+
+The constructor accepts the following `options`:
+
+- **align**: alignment of data within table cells. Must be one of the following:
+
+ - `'right'`: right-aligned.
+ - `'left'`: left-aligned.
+ - `'center'`: center-aligned.
+
+ To specify the alignment of data within each table column, provide an array of alignment specifiers. Default: `'right'`.
+
+- **autoRender**: boolean indicating whether to automatically re-render a table on a `change` event. Default: `false`.
+
+- **borderTop**: top table border character. Default: `'-'`.
+
+- **borderRight**: right table border character. Default: `'|'`.
+
+- **borderBottom**: bottom table border character. Default: `'-'`.
+
+- **borderLeft**: left table border character. Default: `'|'`.
+
+- **borders**: table border characters in the order `[top, right, bottom, left]`. This is a shorthand option instead of specifying borders individually. Default: `[ '─', '│', '─', '│' ]`.
+
+- **bufferSize**: data buffer size. If specified, data is kept in a first-in first-out (FIFO) buffer which cannot exceed the specified buffer size. Default: `+infinity`.
+
+- **columnSeparator**: column separator character(s). Default: `'│'`.
+
+- **columnWidth**: table column width(s). When `null`, column widths are determined according to cell content. When set to a specific width, a column is rendered with the specified width, unless overridden by a `maxColumnWidth` option which is less than the specified width. Default: `null`.
+
+- **cornerTopLeft**: top-left table corner character. Default: `'┌'`.
+
+- **cornerTopRight**: top-right table corner character. Default: `'┌'`.
+
+- **cornerBottomRight**: bottom-right table corner character. Default: `'┘'`.
+
+- **cornerBottomLeft**: bottom-left table corner character. Default: `'└'`.
+
+- **corners**: table corner characters in the order `[top-left, top-right, bottom-right, bottom-left]`. This is a shorthand option instead of specifying corner character sequences individually. Default: `[ '┌', '┐', '┘', '└' ]`.
+
+- **format**: cell [format][@stdlib/string/format] string(s). Default: `'%s'`.
+
+- **headerAlign**: alignment of data within table header cells. Must be one of the following:
+
+ - `'right'`: right-aligned.
+ - `'left'`: left-aligned.
+ - `'center'`: center-aligned.
+
+ To specify the alignment of data within each table column, provide an array of alignment specifiers. Default: `'right'`.
+
+- **headers**: table headers.
+
+- **headerSeparator**: header separator character(s). Default: `'─'`.
+
+- **horizontalSeparatorMode**: horizontal line separator mode. Must be one of the following:
+
+ - `resume`: resume line sequence after a joint.
+ - `interpolate`: skip line character at a joint.
+ - `repeat`: repeat line sequence after a joint.
+
+ Default: `'resume'`.
+
+- **jointMiddle**: joint character connecting table cells within the middle of the table. Default: `'┼'`.
+
+- **jointTop**: joint character connecting table cells along the top of the table. Default: `'┬'`.
+
+- **jointRight**: joint character connecting table cells along the right of the table. Default: `'┤'`.
+
+- **jointBottom**: joint character connecting table cells along the bottom of the table. Default: `'┴'`.
+
+- **jointLeft**: joint character connecting table cells along the left of the table. Default: `'├'`.
+
+- **joints**: joint characters connecting table cells in the order `[middle, top, right, bottom, left]`. This is a shorthand option instead of specifying join character sequences individually. Default: `[ '┼', '┬', '┤', '┴', '├' ]`.
+
+- **marginTop**: margin at the top of the table in units of blank lines. Default: `0`.
+
+- **marginRight**: margin to the right of the table in units of whitespace. Default: `0`.
+
+- **marginBottom**: margin at the bottom of the table in units of blank lines. Default: `0`.
+
+- **marginLeft**: margin to the left of the table in units of whitespace. Default: `0`.
+
+- **margins**: table margins in the order `[top, right, bottom, left]`. This is a shorthand option instead of specifying margins individually. Default: `[ 0, 0, 0, 0 ]`.
+
+- **maxColumnWidth**: maximum table cell width(s). If less than a column's specified width, this option overrides the `columnWidth` option. Default: `+infinity`.
+
+- **maxWidth**: maximum table width. Default: `+infinity`.
+
+- **paddingLeft**: cell left padding in units of whitespace characters. Default: `1`.
+
+- **paddingRight**: cell right padding in units of whitespace characters. Default: `1`.
+
+- **rowSeparator**: row separator character(s). Default: `''`.
+
+- **verticalSeparatorMode**: vertical line separator mode. Must be one of the following:
+
+ - `'resume'`: resume line sequence after a joint.
+ - `'interpolate'`: skip line character at a joint.
+ - `'repeat'`: repeat line sequence after a joint.
+
+ Default: `'resume'`.
+
+* * *
+
+### Writable Properties
+
+
+
+#### UnicodeTable.prototype.align
+
+Alignment(s) of data within table cells.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.align = 'center';
+
+// Get:
+var v = table.align;
+// returns 'center'
+
+// Set:
+table.align = [ 'left', 'right', 'center' ];
+
+// Get:
+v = table.align;
+// returns [ 'left', 'right', 'center' ]
+```
+
+The following alignments are supported:
+
+- **right**: right-aligned.
+- **left**: left-aligned.
+- **center**: center-aligned.
+
+To specify the alignment for each column of table cells, set to an array of alignment values.
+
+
+
+#### UnicodeTable.prototype.autoRender
+
+Rendering mode.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.autoRender = false;
+
+// Get:
+var v = table.autoRender;
+// returns false
+```
+
+If `true`, an instance automatically re-renders a table on each `'change'` event; otherwise, rendering must be triggered manually.
+
+
+
+#### UnicodeTable.prototype.borderTop
+
+Top table border character.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.borderTop = '=';
+
+// Get:
+var v = table.borderTop;
+// returns '='
+```
+
+
+
+#### UnicodeTable.prototype.borderRight
+
+Right table border character.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.borderRight = '!';
+
+// Get:
+var v = table.borderRight;
+// returns '!'
+```
+
+
+
+#### UnicodeTable.prototype.borderBottom
+
+Bottom table border character.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.borderBottom = '=';
+
+// Get:
+var v = table.borderBottom;
+// returns '='
+```
+
+
+
+#### UnicodeTable.prototype.borderLeft
+
+Left table border character.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.borderLeft = '!';
+
+// Get:
+var v = table.borderLeft;
+// returns '!'
+```
+
+
+
+#### UnicodeTable.prototype.borders
+
+Table border characters in the order `[ 'top', 'right', 'bottom', 'left' ]`.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.borders = [ '=', '!', '=', '!' ];
+
+// Get:
+var v = table.borders;
+// returns [ '=', '!', '=', '!' ]
+```
+
+
+
+#### UnicodeTable.prototype.bufferSize
+
+Data buffer size.
+
+```javascript
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+
+var table = new UnicodeTable();
+
+// Set:
+table.bufferSize = 3;
+
+// Get:
+var v = table.bufferSize;
+// returns 3
+
+table.data = [ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ] ];
+
+var data = ndarray2array( table.data );
+// returns [ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ] ]
+
+table.push( [ 7, 8 ] );
+
+data = ndarray2array( table.data );
+// returns [ [ 3, 4 ], [ 5, 6 ], [ 7, 8 ] ]
+```
+
+If set, this specifies the maximum number of table rows which can be rendered. Once an internal data buffer is full, each new table row results in the oldest table row being removed.
+
+Setting a data buffer size is useful when rendering data streams.
+
+
+
+#### UnicodeTable.prototype.columnSeparator
+
+Table column separator character(s).
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.columnSeparator = '|';
+
+// Get:
+var v = table.columnSeparator;
+// returns '|'
+```
+
+If provided a string with multiple grapheme clusters, each grapheme cluster is rendered sequentially. No separator is rendered if provided an empty string.
+
+
+
+#### UnicodeTable.prototype.columnWidth
+
+Table column width.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.columnWidth = 10;
+
+// Get:
+var v = table.columnWidth;
+// returns 10
+
+// Set:
+table.columnWidth = [ 10, 15 ];
+
+// Get:
+v = table.columnWidth;
+// returns [ 10, 15 ]
+```
+
+When `null`, table column widths are determined according to cell content. When set to a specific width, a table column is rendered with the specified width, unless overridden by a [`maxColumnWidth`](#prop-max-column-width) which is less than the specified width.
+
+If table column data is longer than a specified column width, the rendered column data is truncated.
+
+To specify a table column width for each column, provide an array of widths.
+
+
+
+#### UnicodeTable.prototype.cornerTopLeft
+
+Top-left table corner character.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.cornerTopLeft = '*';
+
+// Get:
+var v = table.cornerTopLeft;
+// returns '*'
+```
+
+
+
+#### UnicodeTable.prototype.cornerTopRight
+
+Top-right table corner character.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.cornerTopRight = '*';
+
+// Get:
+var v = table.cornerTopRight;
+// returns '*'
+```
+
+
+
+#### UnicodeTable.prototype.cornerBottomRight
+
+Bottom-right table corner character.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.cornerBottomRight = '*';
+
+// Get:
+var v = table.cornerBottomRight;
+// returns '*'
+```
+
+
+
+#### UnicodeTable.prototype.cornerBottomLeft
+
+Bottom-left table corner character.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.cornerBottomLeft = '*';
+
+// Get:
+var v = table.cornerBottomLeft;
+// returns '*'
+```
+
+
+
+#### UnicodeTable.prototype.corners
+
+Table corner characters in the order `[ 'top-left', 'top-right', 'bottom-right', 'bottom-left' ]`.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.corners = [ '*', '*', '*', '*' ];
+
+// Get:
+var v = table.corners;
+// returns [ '*', '*', '*', '*' ]
+```
+
+
+
+#### UnicodeTable.prototype.data
+
+Table data.
+
+```javascript
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+
+var table = new UnicodeTable();
+
+// Set:
+table.data = [ [ 1, 2 ], [ 3, 4 ] ];
+
+// Get:
+var data = ndarray2array( table.data );
+// returns [ [ 1, 2 ], [ 3, 4 ] ]
+```
+
+The returned [ndarray][@stdlib/ndarray/ctor] is a **read-only** view of table data.
+
+
+
+#### UnicodeTable.prototype.format
+
+Cell [format][@stdlib/string/format] string(s) for rendering cell contents.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.format = '%d';
+
+// Get:
+var v = table.format;
+// returns '%d'
+
+// Set:
+table.format = [ '%s', '%d' ];
+
+// Get:
+v = table.format;
+// returns [ '%s', '%d' ]
+```
+
+
+
+#### UnicodeTable.prototype.headerAlign
+
+Alignment(s) of data within table header cells.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.headerAlign = 'center';
+
+// Get:
+var v = table.headerAlign;
+// returns 'center'
+
+// Set:
+table.headerAlign = [ 'left', 'right', 'center' ];
+
+// Get:
+v = table.headerAlign;
+// returns [ 'left', 'right', 'center' ]
+```
+
+By default and when set to `null`, the alignment of header cell data matches that of [`table.align`](#prop-align). To specify an alignment which diverges from data cell alignment, specify an alternative alignment.
+
+The following alignments are supported:
+
+- **right**: right-aligned.
+- **left**: left-aligned.
+- **center**: center-aligned.
+
+To specify the alignment for each header column individually, set to an array of alignment values.
+
+
+
+#### UnicodeTable.prototype.headers
+
+Table headers.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.headers = [ 'A', 'B' ];
+
+// Get:
+var v = table.headers;
+// returns [ 'A', 'B' ]
+```
+
+
+
+#### UnicodeTable.prototype.headerSeparator
+
+Header separator character(s).
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.headerSeparator = '-';
+
+// Get:
+var v = table.headerSeparator;
+// returns '-'
+```
+
+If provided a string with multiple grapheme clusters, each grapheme cluster is rendered sequentially. No separator is rendered if provided an empty string.
+
+
+
+#### UnicodeTable.prototype.horizontalSeparatorMode
+
+Horizontal line separator mode.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.horizontalSeparatorMode = 'interpolate';
+
+// Get:
+var v = table.horizontalSeparatorMode;
+// returns 'interpolate'
+```
+
+The following modes are supported:
+
+- **resume**: resume line sequence after a joint.
+- **interpolate**: skip line character at a joint.
+- **repeat**: repeat line sequence after a joint.
+
+
+
+#### UnicodeTable.prototype.jointMiddle
+
+Joint character connecting cells within the middle of the table.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.jointMiddle = '*';
+
+// Get:
+var v = table.jointMiddle;
+// returns '*'
+```
+
+
+
+#### UnicodeTable.prototype.jointTop
+
+Joint character connecting cells along the top of the table.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.jointTop = '*';
+
+// Get:
+var v = table.jointTop;
+// returns '*'
+```
+
+
+
+#### UnicodeTable.prototype.jointRight
+
+Joint character connecting cells along the right side of the table.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.jointRight = '*';
+
+// Get:
+var v = table.jointRight;
+// returns '*'
+```
+
+
+
+#### UnicodeTable.prototype.jointBottom
+
+Joint character connecting cells along the bottom of the table.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.jointBottom = '*';
+
+// Get:
+var v = table.jointBottom;
+// returns '*'
+```
+
+
+
+#### UnicodeTable.prototype.jointLeft
+
+Joint character connecting cells along the left side of the table.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.jointLeft = '*';
+
+// Get:
+var v = table.jointLeft;
+// returns '*'
+```
+
+
+
+#### UnicodeTable.prototype.joints
+
+Joint characters in the order `[ 'middle', 'top', 'right', 'bottom', 'left' ]`.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.joints = [ '*', '*', '*', '*', '*' ];
+
+// Get:
+var v = table.joints;
+// returns [ '*', '*', '*', '*', '*' ]
+```
+
+
+
+#### UnicodeTable.prototype.marginTop
+
+Margin at the top of the table in units of blank lines.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.marginTop = 2;
+
+// Get:
+var v = table.marginTop;
+// returns 2
+```
+
+
+
+#### UnicodeTable.prototype.marginRight
+
+Margin to the right of the table in units of whitespace.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.marginRight = 2;
+
+// Get:
+var v = table.marginRight;
+// returns 2
+```
+
+
+
+#### UnicodeTable.prototype.marginBottom
+
+Margin at the bottom of the table in units of blank lines.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.marginBottom = 2;
+
+// Get:
+var v = table.marginBottom;
+// returns 2
+```
+
+
+
+#### UnicodeTable.prototype.marginLeft
+
+Margin to the left of the table in units of whitespace.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.marginLeft = 2;
+
+// Get:
+var v = table.marginLeft;
+// returns 2
+```
+
+
+
+#### UnicodeTable.prototype.margins
+
+Table margins in the order of `[ top, right, bottom, left ]`.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.margins = [ 2, 2, 2, 2 ];
+
+// Get:
+var v = table.margins;
+// returns [ 2, 2, 2, 2 ]
+```
+
+
+
+#### UnicodeTable.prototype.maxColumnWidth
+
+Maximum table column width.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.maxColumnWidth = 10;
+
+// Get:
+var v = table.maxColumnWidth;
+// returns 10
+
+// Set:
+table.maxColumnWidth = [ 10, 15 ];
+
+// Get:
+v = table.maxColumnWidth;
+// returns [ 10, 15 ]
+```
+
+If table column data is longer than the maximum column width, the rendered column data is truncated. To specify the maximum column width for each table column, provide an array of maximum widths.
+
+If set to a value which is less than a column's specified width, the maximum table column width takes precedence over [`columnWidth`](#prop-column-width).
+
+
+
+#### UnicodeTable.prototype.maxWidth
+
+Maximum table width.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.maxWidth = 200;
+
+// Get:
+var v = table.maxWidth;
+// returns 200
+```
+
+If the generated table is longer than the maximum table width, a generated table is split into multiple tables.
+
+
+
+#### UnicodeTable.prototype.paddingLeft
+
+Cell left padding(s) in units of whitespace.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.paddingLeft = 3;
+
+// Get:
+var v = table.paddingLeft;
+// returns 3
+
+// Set:
+table.paddingLeft = [ 3, 4 ];
+
+// Get:
+v = table.paddingLeft;
+// returns [ 3, 4 ]
+```
+
+To specify the padding of each column of table cells, provide an array of paddings.
+
+
+
+#### UnicodeTable.prototype.paddingRight
+
+Cell right padding(s) in units of whitespace.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.paddingRight = 3;
+
+// Get:
+var v = table.paddingRight;
+// returns 3
+
+// Set:
+table.paddingRight = [ 3, 4 ];
+
+// Get:
+v = table.paddingRight;
+// returns [ 3, 4 ]
+```
+
+To specify the padding of each column of table cells, provide an array of paddings.
+
+
+
+#### UnicodeTable.prototype.rowSeparator
+
+Row separator character(s).
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.rowSeparator = '-';
+
+// Get:
+var v = table.rowSeparator;
+// returns '-'
+```
+
+If provided a string with multiple grapheme clusters, each grapheme cluster is rendered sequentially. No separator is rendered if provided an empty string.
+
+
+
+#### UnicodeTable.prototype.verticalSeparatorMode
+
+Vertical line separator mode.
+
+```javascript
+var table = new UnicodeTable();
+
+// Set:
+table.verticalSeparatorMode = 'interpolate';
+
+// Get:
+var v = table.verticalSeparatorMode;
+// returns 'interpolate'
+```
+
+The following modes are supported:
+
+- **resume**: resume line sequence after a joint.
+- **interpolate**: skip line character at a joint.
+- **repeat**: repeat line sequence after a joint.
+
+* * *
+
+### Methods
+
+
+
+#### UnicodeTable.prototype.get( i, j )
+
+Retrieves the data for a specified table cell.
+
+```javascript
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+
+var table = new UnicodeTable( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] );
+
+// Retrieve individual cell data:
+var v = table.get( 0, 0 );
+// returns 1
+
+v = table.get( 1, 2 );
+// returns 6
+```
+
+
+
+#### UnicodeTable.prototype.push( data )
+
+Appends one or more rows to table data. Each provided row must have the same number of columns as existing table data.
+
+```javascript
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+
+var table = new UnicodeTable( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] );
+
+// Get:
+var data = ndarray2array( table.data );
+// returns [ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
+
+// Push:
+table.push( [ 7, 8, 9 ] );
+
+// Get:
+data = ndarray2array( table.data );
+// returns [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ]
+```
+
+
+
+#### UnicodeTable.prototype.render()
+
+Renders a Unicode table.
+
+```javascript
+var headers = [ 'col1', 'col2', 'col3' ];
+var data = [ [ 1, 2, 3 ], [ 4, 5, 6 ] ];
+
+var table = new UnicodeTable( data, {
+ 'headers': headers
+});
+
+var str = table.render();
+// returns '...'
+```
+
+
+
+#### UnicodeTable.prototype.set( i, j, value )
+
+Sets the data for a specified table cell to a provided value.
+
+```javascript
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+
+var table = new UnicodeTable( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] );
+
+// Retrieve individual cell data:
+var v = table.get( 1, 1 );
+// returns 5
+
+table.set( 1, 1, 7 );
+
+v = table.get( 1, 1 );
+// returns 7
+```
+
+* * *
+
+### Events
+
+#### 'change'
+
+Emitted whenever a property value changes.
+
+```javascript
+var table = new UnicodeTable();
+
+table.on( 'change', onChange );
+
+function onChange() {
+ console.log( 'A property was updated.' );
+}
+```
+
+#### 'render'
+
+Emitted whenever a table is rendered.
+
+```javascript
+var table = new UnicodeTable();
+
+table.on( 'render', onRender );
+
+function onRender( str ) {
+ console.log( 'Rendered table: %s', str );
+}
+```
+
+
+
+
+
+
+
+* * *
+
+## Notes
+
+- Once a table instance has resolved the number of table columns (e.g., by setting table headers, binding table data, specifying column paddings, or specifying column alignments), the number of table columns is fixed. In order to remove or add table columns, create a new table instance with the desired configuration.
+- When rendering a Unicode table to terminals, be advised that emojis can cause alignment issues due to variability in how many terminal columns an emoji occupies. This is particularly true for emoji using skin tones.
+
+
+
+
+
+
+
+* * *
+
+## Examples
+
+
+
+
+
+```javascript
+var uniform = require( '@stdlib/random/array/uniform' );
+var array = require( '@stdlib/ndarray/array' );
+var UnicodeTable = require( '@stdlib/plot/table/unicode' );
+
+// Generate a random data set:
+var data = array( uniform( 50, 1.0, 100.0 ), {
+ 'shape': [ 10, 5 ]
+});
+
+// Define column headers:
+var headers = [ 'A', 'B', 'C', 'D', 'E' ];
+
+// Create a table:
+var table = new UnicodeTable( data, {
+ 'headers': headers,
+ 'rowSeparator': '-',
+ 'columnSeparator': '#$%',
+ 'maxWidth': 200,
+ 'marginLeft': 5,
+ 'marginRight': 5,
+ 'align': 'right',
+ 'headerAlign': [
+ 'left',
+ 'center',
+ 'right',
+ 'center',
+ 'left'
+ ],
+ 'format': '%0.5f'
+});
+
+// Render the table:
+var str = table.render();
+console.log( str );
+// => '...'
+
+// Push new data to the table:
+table.push( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+
+// Re-render the table:
+str = table.render();
+console.log( str );
+// => '...'
+
+// Limit the number of table rows:
+table.bufferSize = 10;
+
+// Re-render the table:
+str = table.render();
+console.log( str );
+// => '...'
+
+// Push new data to the table:
+table.push( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+// Re-render the table:
+str = table.render();
+console.log( str );
+// => '...'
+
+// Increase the number of allowed table rows:
+table.bufferSize = 15;
+
+// Push new data to the table:
+table.push( [ 11.0, 12.0, 13.0, 14.0, 15.0 ] );
+
+// Re-render the table:
+str = table.render();
+console.log( str );
+// => '...'
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[@stdlib/ndarray/ctor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/ctor
+
+[@stdlib/string/format]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/string/format
+
+
+
+
+
+
+
+
diff --git a/lib/node_modules/@stdlib/plot/table/unicode/benchmark/benchmark.js b/lib/node_modules/@stdlib/plot/table/unicode/benchmark/benchmark.js
new file mode 100644
index 000000000000..fea52d4b6355
--- /dev/null
+++ b/lib/node_modules/@stdlib/plot/table/unicode/benchmark/benchmark.js
@@ -0,0 +1,1433 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var isString = require( '@stdlib/assert/is-string' ).isPrimitive;
+var isNumber = require( '@stdlib/assert/is-number' ).isPrimitive;
+var isBoolean = require( '@stdlib/assert/is-boolean' ).isPrimitive;
+var isArray = require( '@stdlib/assert/is-array' );
+var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var pkg = require( './../package.json' ).name;
+var UnicodeTable = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg+'::instantiation', function benchmark( b ) {
+ var v;
+ var i;
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = new UnicodeTable();
+ if ( !( v instanceof UnicodeTable ) ) {
+ b.fail( 'should return an instance' );
+ }
+ }
+ b.toc();
+ if ( !( v instanceof UnicodeTable ) ) {
+ b.fail( 'should return an instance' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::instantiation,no_new', function benchmark( b ) {
+ var ctor;
+ var v;
+ var i;
+
+ ctor = UnicodeTable;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = ctor();
+ if ( !( v instanceof UnicodeTable ) ) {
+ b.fail( 'should return an instance' );
+ }
+ }
+ b.toc();
+ if ( !( v instanceof UnicodeTable ) ) {
+ b.fail( 'should return an instance' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::instantiation,data', function benchmark( b ) {
+ var v;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = new UnicodeTable( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] );
+ if ( !( v instanceof UnicodeTable ) ) {
+ b.fail( 'should return an instance' );
+ }
+ }
+ b.toc();
+ if ( !( v instanceof UnicodeTable ) ) {
+ b.fail( 'should return an instance' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::instantiation,data,headers', function benchmark( b ) {
+ var v;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = new UnicodeTable( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] );
+ if ( !( v instanceof UnicodeTable ) ) {
+ b.fail( 'should return an instance' );
+ }
+ }
+ b.toc();
+ if ( !( v instanceof UnicodeTable ) ) {
+ b.fail( 'should return an instance' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::instantiation,data,options', function benchmark( b ) {
+ var opts;
+ var v;
+ var i;
+
+ opts = {
+ 'align': 'left',
+ 'autoRender': false,
+ 'borderTop': '1',
+ 'borderRight': '23',
+ 'borderBottom': '456',
+ 'borderLeft': '7890',
+ 'borders': [ '1', '23', '456', '7890' ],
+ 'bufferSize': 10,
+ 'columnWidth': null,
+ 'columnSeparator': 'None',
+ 'cornerTopLeft': '*',
+ 'cornerTopRight': '*',
+ 'cornerBottomLeft': '*',
+ 'cornerBottomRight': '*',
+ 'corners': [ '*', '*', '*', '*' ],
+ 'format': '%d',
+ 'headerAlign': 'center',
+ 'headers': [ 'col1', 'col2', 'col3' ],
+ 'headerSeparator': '-=',
+ 'horizontalSeparatorMode': 'repeat',
+ 'jointMiddle': '*',
+ 'jointTop': '*',
+ 'jointRight': '*',
+ 'jointBottom': '*',
+ 'jointLeft': '*',
+ 'joints': [ '*', '*', '*', '*', '*' ],
+ 'marginTop': 4,
+ 'marginRight': 2,
+ 'marginBottom': 4,
+ 'marginLeft': 2,
+ 'margins': [ 4, 2, 4, 2 ],
+ 'maxColumnWidth': 10,
+ 'maxWidth': 60,
+ 'paddingLeft': 2,
+ 'paddingRight': [ 2, 3, 4 ],
+ 'rowSeparator': '_-',
+ 'verticalSeparatorMode': 'resume'
+ };
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = new UnicodeTable( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ], opts );
+ if ( !( v instanceof UnicodeTable ) ) {
+ b.fail( 'should return an instance' );
+ }
+ }
+ b.toc();
+ if ( !( v instanceof UnicodeTable ) ) {
+ b.fail( 'should return an instance' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:align:value=string', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ 'left',
+ 'center',
+ 'right'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.align = values[ i % values.length ];
+ if ( !isString( v.align ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.align ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:align:value=array', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ [ 'left', 'right' ],
+ [ 'center', 'right' ],
+ [ 'left', 'center' ]
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.align = values[ i % values.length ];
+ if ( !isArray( v.align ) ) {
+ b.fail( 'should return an array' );
+ }
+ }
+ b.toc();
+ if ( !isArray( v.align ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:autoRender', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ false,
+ true
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.autoRender = values[ i % values.length ];
+ if ( !isBoolean( v.autoRender ) ) {
+ b.fail( 'should return a boolean' );
+ }
+ }
+ b.toc();
+ if ( !isBoolean( v.autoRender ) ) {
+ b.fail( 'should return a boolean' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:borderTop', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '1',
+ '2'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.borderTop = values[ i % values.length ];
+ if ( !isString( v.borderTop ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.borderTop ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:borderRight', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '1',
+ '2'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.borderRight = values[ i % values.length ];
+ if ( !isString( v.borderRight ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.borderRight ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:borderBottom', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '1',
+ '2'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.borderBottom = values[ i % values.length ];
+ if ( !isString( v.borderBottom ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.borderBottom ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:borderLeft', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '1',
+ '2'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.borderLeft = values[ i % values.length ];
+ if ( !isString( v.borderLeft ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.borderLeft ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:borders', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ [ '-', '|', '-', '|' ],
+ [ '1', '23', '456', '7890' ],
+ [ '', '', '', '' ],
+ [ '🌹', '🥀', '🔥', '👍' ]
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.borders = values[ i % values.length ];
+ if ( !isArray( v.borders ) ) {
+ b.fail( 'should return an array' );
+ }
+ }
+ b.toc();
+ if ( !isArray( v.borders ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:bufferSize', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ 1,
+ 2,
+ 3,
+ null
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.bufferSize = values[ i % values.length ];
+ if ( !isNumber( v.bufferSize ) ) {
+ b.fail( 'should return a number' );
+ }
+ }
+ b.toc();
+ if ( !isNumber( v.bufferSize ) ) {
+ b.fail( 'should return a number' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:columnSeparator', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '|',
+ '123',
+ '🥀',
+ ''
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.columnSeparator = values[ i % values.length ];
+ if ( !isString( v.columnSeparator ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.columnSeparator ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:columnWidth:value=number', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ 10,
+ 20,
+ 30,
+ 40
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.columnWidth = values[ i % values.length ];
+ if ( !isNumber( v.columnWidth ) ) {
+ b.fail( 'should return a number' );
+ }
+ }
+ b.toc();
+ if ( !isNumber( v.columnWidth ) ) {
+ b.fail( 'should return a number' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:columnWidth:value=array', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ [ 1, 2, 3 ],
+ [ 4, 5, 6 ],
+ [ 7, null, 9 ],
+ [ null, null, null ]
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.columnWidth = values[ i % values.length ];
+ if ( !isArray( v.columnWidth ) ) {
+ b.fail( 'should return an array' );
+ }
+ }
+ b.toc();
+ if ( !isArray( v.columnWidth ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:cornerTopLeft', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '-',
+ '*'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.cornerTopLeft = values[ i % values.length ];
+ if ( !isString( v.cornerTopLeft ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.cornerTopLeft ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:cornerTopRight', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '-',
+ '*'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.cornerTopRight = values[ i % values.length ];
+ if ( !isString( v.cornerTopRight ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.cornerTopRight ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:cornerBottomRight', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '-',
+ '*'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.cornerBottomRight = values[ i % values.length ];
+ if ( !isString( v.cornerBottomRight ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.cornerBottomRight ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:cornerBottomLeft', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '-',
+ '*'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.cornerBottomLeft = values[ i % values.length ];
+ if ( !isString( v.cornerBottomLeft ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.cornerBottomLeft ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:corners', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ [ '-', '|', '-', '|' ],
+ [ '🌹', '🥀', '🔥', '👍' ]
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.corners = values[ i % values.length ];
+ if ( !isArray( v.corners ) ) {
+ b.fail( 'should return an array' );
+ }
+ }
+ b.toc();
+ if ( !isArray( v.corners ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:data:value=nested_array', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ [ [ 1, 2, 3 ], [ 4, 5, 6 ] ],
+ [ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.data = values[ i % values.length ];
+ if ( typeof v.data !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( v.data ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:data:value=dictionary_of_columns', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ {
+ 'a': [ 1, 2, 3 ],
+ 'b': [ 4, 5, 6 ]
+ },
+ {
+ 'a': [ 1, 2, 3 ],
+ 'b': [ 4, 5, 6 ]
+ }
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.data = values[ i % values.length ];
+ if ( typeof v.data !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( v.data ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:data:value=ndarray', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ ndarray( 'generic', [ 1, 2, 3, 4, 5, 6 ], [ 2, 3 ], [ 3, 1 ], 0, 'row-major' ),
+ ndarray( 'generic', [ 1, 2, 3, 4, 5, 6 ], [ 2, 3 ], [ 3, 1 ], 0, 'row-major' )
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.data = values[ i % values.length ];
+ if ( typeof v.data !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( v.data ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:format:value=string', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '%d',
+ '%f'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.format = values[ i % values.length ];
+ if ( !isString( v.format ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.format ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:format:value=array', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ [ '%d' ],
+ [ '%f' ]
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.format = values[ i % values.length ];
+ if ( !isArray( v.format ) ) {
+ b.fail( 'should return an array' );
+ }
+ }
+ b.toc();
+ if ( !isArray( v.format ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:headerAlign:value=string', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ 'left',
+ 'center',
+ 'right'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.headerAlign = values[ i % values.length ];
+ if ( !isString( v.headerAlign ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.headerAlign ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:headerAlign:value=array', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ [ 'left', 'right' ],
+ [ 'center', 'right' ],
+ [ 'left', 'center' ]
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.headerAlign = values[ i % values.length ];
+ if ( !isArray( v.headerAlign ) ) {
+ b.fail( 'should return an array' );
+ }
+ }
+ b.toc();
+ if ( !isArray( v.headerAlign ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:headers', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ [ 'col1', 'col2', 'col3' ],
+ [ 1, 2, 3 ]
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.headers = values[ i % values.length ];
+ if ( !isArray( v.headers ) ) {
+ b.fail( 'should return an array' );
+ }
+ }
+ b.toc();
+ if ( !isArray( v.headers ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:headerSeparator', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '|',
+ '123',
+ '🥀',
+ ''
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.headerSeparator = values[ i % values.length ];
+ if ( !isString( v.headerSeparator ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.headerSeparator ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:horizontalSeparatorMode', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ 'repeat',
+ 'resume',
+ 'interpolate'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.horizontalSeparatorMode = values[ i % values.length ];
+ if ( !isString( v.horizontalSeparatorMode ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.horizontalSeparatorMode ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:jointMiddle', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '-',
+ '*'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.jointMiddle = values[ i % values.length ];
+ if ( !isString( v.jointMiddle ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.jointMiddle ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:jointTop', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '-',
+ '*'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.jointTop = values[ i % values.length ];
+ if ( !isString( v.jointTop ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.jointTop ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:jointRight', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '-',
+ '*'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.jointRight = values[ i % values.length ];
+ if ( !isString( v.jointRight ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.jointRight ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:jointBottom', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '-',
+ '*'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.jointBottom = values[ i % values.length ];
+ if ( !isString( v.jointBottom ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.jointBottom ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:jointLeft', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '-',
+ '*'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.jointLeft = values[ i % values.length ];
+ if ( !isString( v.jointLeft ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.jointLeft ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:joints', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ [ '-', '|', '-', '|', '=' ],
+ [ '🌹', '🥀', '🔥', '👍', '📸' ]
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.joints = values[ i % values.length ];
+ if ( !isArray( v.joints ) ) {
+ b.fail( 'should return an array' );
+ }
+ }
+ b.toc();
+ if ( !isArray( v.joints ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:marginTop', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ 0,
+ 1,
+ 2
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.marginTop = values[ i % values.length ];
+ if ( !isNumber( v.marginTop ) ) {
+ b.fail( 'should return a number' );
+ }
+ }
+ b.toc();
+ if ( !isNumber( v.marginTop ) ) {
+ b.fail( 'should return a number' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:marginRight', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ 0,
+ 1,
+ 2
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.marginRight = values[ i % values.length ];
+ if ( !isNumber( v.marginRight ) ) {
+ b.fail( 'should return a number' );
+ }
+ }
+ b.toc();
+ if ( !isNumber( v.marginRight ) ) {
+ b.fail( 'should return a number' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:marginBottom', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ 0,
+ 1,
+ 2
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.marginBottom = values[ i % values.length ];
+ if ( !isNumber( v.marginBottom ) ) {
+ b.fail( 'should return a number' );
+ }
+ }
+ b.toc();
+ if ( !isNumber( v.marginBottom ) ) {
+ b.fail( 'should return a number' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:marginLeft', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ 0,
+ 1,
+ 2
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.marginLeft = values[ i % values.length ];
+ if ( !isNumber( v.marginLeft ) ) {
+ b.fail( 'should return a number' );
+ }
+ }
+ b.toc();
+ if ( !isNumber( v.marginLeft ) ) {
+ b.fail( 'should return a number' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:margins', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ [ 0, 0, 0, 0 ],
+ [ 1, 2, 3, 4 ]
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.margins = values[ i % values.length ];
+ if ( !isArray( v.margins ) ) {
+ b.fail( 'should return an array' );
+ }
+ }
+ b.toc();
+ if ( !isArray( v.margins ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:maxColumnWidth:value=number', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ 10,
+ 20,
+ 30,
+ null
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.maxColumnWidth = values[ i % values.length ];
+ if ( !isNumber( v.maxColumnWidth ) ) {
+ b.fail( 'should return a number' );
+ }
+ }
+ b.toc();
+ if ( !isNumber( v.maxColumnWidth ) ) {
+ b.fail( 'should return a number' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:maxColumnWidth:value=array', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ [ 1, 2, 3 ],
+ [ 4, 5, 6 ],
+ [ 7, null, 9 ],
+ [ null, null, null ]
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.maxColumnWidth = values[ i % values.length ];
+ if ( !isArray( v.maxColumnWidth ) ) {
+ b.fail( 'should return an array' );
+ }
+ }
+ b.toc();
+ if ( !isArray( v.maxColumnWidth ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:maxWidth', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ 100,
+ 200,
+ 300,
+ null
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.maxWidth = values[ i % values.length ];
+ if ( !isNumber( v.maxWidth ) ) {
+ b.fail( 'should return a number' );
+ }
+ }
+ b.toc();
+ if ( !isNumber( v.maxWidth ) ) {
+ b.fail( 'should return a number' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:paddingLeft:value=number', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ 1,
+ 2,
+ 3
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.paddingLeft = values[ i % values.length ];
+ if ( !isNumber( v.paddingLeft ) ) {
+ b.fail( 'should return a number' );
+ }
+ }
+ b.toc();
+ if ( !isNumber( v.paddingLeft ) ) {
+ b.fail( 'should return a number' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:paddingLeft:value=array', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ [ 1, 2 ],
+ [ 3, 4 ],
+ [ 5, 6 ]
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.paddingLeft = values[ i % values.length ];
+ if ( !isArray( v.paddingLeft ) ) {
+ b.fail( 'should return an array' );
+ }
+ }
+ b.toc();
+ if ( !isArray( v.paddingLeft ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:paddingRight:value=number', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ 1,
+ 2,
+ 3
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.paddingRight = values[ i % values.length ];
+ if ( !isNumber( v.paddingRight ) ) {
+ b.fail( 'should return a number' );
+ }
+ }
+ b.toc();
+ if ( !isNumber( v.paddingRight ) ) {
+ b.fail( 'should return a number' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:paddingRight:value=array', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ [ 1, 2 ],
+ [ 3, 4 ],
+ [ 5, 6 ]
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.paddingRight = values[ i % values.length ];
+ if ( !isArray( v.paddingRight ) ) {
+ b.fail( 'should return an array' );
+ }
+ }
+ b.toc();
+ if ( !isArray( v.paddingRight ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:rowSeparator', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '|',
+ '123',
+ '🥀',
+ ''
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.rowSeparator = values[ i % values.length ];
+ if ( !isString( v.rowSeparator ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.rowSeparator ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::set,get:verticalSeparatorMode', function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ 'repeat',
+ 'resume',
+ 'interpolate'
+ ];
+ v = new UnicodeTable();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v.verticalSeparatorMode = values[ i % values.length ];
+ if ( !isString( v.verticalSeparatorMode ) ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v.verticalSeparatorMode ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/plot/table/unicode/benchmark/benchmark.render.js b/lib/node_modules/@stdlib/plot/table/unicode/benchmark/benchmark.render.js
new file mode 100644
index 000000000000..581b31276824
--- /dev/null
+++ b/lib/node_modules/@stdlib/plot/table/unicode/benchmark/benchmark.render.js
@@ -0,0 +1,116 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var random = require( '@stdlib/random/array/discrete-uniform' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var array = require( '@stdlib/ndarray/array' );
+var pkg = require( './../package.json' ).name;
+var UnicodeTable = require( './../lib' );
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} rows - number of rows
+* @param {PositiveInteger} columns - number of columns
+* @param {UnicodeTable} table - table instance
+* @returns {Function} benchmark function
+*/
+function createBenchmark( rows, columns, table ) {
+ var data;
+
+ data = random( rows*columns, 0, 100, {
+ 'dtype': 'float64'
+ });
+ table.data = array( data, {
+ 'shape': [ rows, columns ]
+ });
+ table.headers = random( columns, 0, columns, {
+ 'dtype': 'generic'
+ });
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var str;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ str = table.render();
+ if ( typeof str !== 'string' ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( typeof str !== 'string' ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var columns;
+ var table;
+ var rows;
+ var min;
+ var max;
+ var f;
+ var i;
+ var j;
+
+ min = 1; // 5^min
+ max = 3; // 5^max
+
+ for ( i = min; i <= max; i++ ) {
+ for ( j = min; j <= max; j++ ) {
+ rows = pow( 5, i );
+ columns = pow( 5, j );
+
+ table = new UnicodeTable();
+ table.bufferSize = rows;
+ f = createBenchmark( rows, columns, table );
+ bench( pkg+':render:rows='+rows+',columns='+columns, f );
+ }
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/plot/table/unicode/docs/repl.txt b/lib/node_modules/@stdlib/plot/table/unicode/docs/repl.txt
new file mode 100644
index 000000000000..3d21d410caf0
--- /dev/null
+++ b/lib/node_modules/@stdlib/plot/table/unicode/docs/repl.txt
@@ -0,0 +1,308 @@
+
+{{alias}}( [data,] [options] )
+ Returns a Unicode table instance.
+
+ Parameters
+ ----------
+ data: Object|Array