A high-performance virtual table component for vanilla JavaScript.
- High Performance - Virtual scrolling renders only visible rows, handling hundreds of thousands of rows smoothly
- Column Management - Sort, resize, reorder, and hide/show columns
- Multi-column Sorting - Sort by multiple columns simultaneously
- Flexible Column Widths - Mix absolute, relative, and auto-calculated widths
- Cell Preview - Hover tooltips for truncated cell content
- Sticky Columns - Pin columns to the start or end of the table
- Sticky End Rows - Pin totals, summary or control rows to the bottom of the table
- RTL Support - Native right-to-left language support
- Variable Row Height - Support for rows with different heights
- Filtering - Built-in filtering with custom filter function support
- Web Worker Support - Load data asynchronously via Web Workers
npm install @danielgindi/dgtable.jsThe ES module and CommonJS builds import their dependencies (@danielgindi/dom-utils, @danielgindi/virtual-list-helper) as packages. The UMD build (dist/lib.umd.js) expects them as globals:
<script src="node_modules/@danielgindi/dom-utils/dist/lib.umd.js"></script>
<script src="node_modules/@danielgindi/virtual-list-helper/dist/virtual-list-helper.umd.js"></script>
<script>
window.domUtilsScrollHelper = domutils.ScrollHelper;
window.domUtilsDomCompat = domutils.DomCompat;
window.domUtilsDomEventsSink = domutils.DomEventsSink.default;
window.domUtilsCss = domutils.Css;
</script>
<script src="node_modules/@danielgindi/dgtable.js/dist/lib.umd.js"></script>import DGTable from '@danielgindi/dgtable.js';
const table = new DGTable({
columns: [
{ name: 'id', label: 'ID', width: 80 },
{ name: 'name', label: 'Name', width: '30%' },
{ name: 'email', label: 'Email' },
],
height: 400,
virtualTable: true,
});
document.getElementById('container').appendChild(table.el);
table.setRows([
{ id: 1, name: 'John Doe', email: 'john@example.com' },
{ id: 2, name: 'Jane Smith', email: 'jane@example.com' },
]);
table.render();If you're migrating from the older jQuery version:
- No
$elproperty - usetable.elinstead - No auto-clear of jQuery data
- Use
emit()instead oftrigger()for events - Event arguments are now always a single value/object
- DOM element properties:
'columnName'on cells,'index'/'vIndex'on rows
new DGTable(options?: DGTableOptions)| Option | Type | Default | Description |
|---|---|---|---|
el |
Element |
- | Optional existing element to use as container |
className |
string |
'dgtable-wrapper' |
CSS class for the wrapper element |
height |
number |
- | Table height in pixels |
width |
DGTable.Width |
NONE |
Width handling mode: NONE, AUTO, or SCROLL |
virtualTable |
boolean |
true |
Enable virtual scrolling (recommended for large datasets) |
estimatedRowHeight |
number |
40 |
Estimated row height for virtual scrolling calculations |
rowsBufferSize |
number |
3 |
Number of rows to render outside visible area |
| Option | Type | Default | Description |
|---|---|---|---|
columns |
ColumnOptions[] |
[] |
Array of column definitions |
minColumnWidth |
number |
35 |
Minimum column width in pixels |
maxStickyColumnRelativeWidth |
number? |
null | Maximum relative width for a sticky column |
columnAutoWidthExtraSize |
number? |
0 |
Extra width in pixels added to auto-fit column widths |
resizableColumns |
boolean |
true |
Allow column resizing |
movableColumns |
boolean |
true |
Allow column reordering |
maxColumnsSortCount |
number |
1 |
Maximum number of columns to sort by |
allowCancelSort |
boolean |
true |
Allow cycling through asc → desc → none |
adjustColumnWidthForSortArrow |
boolean |
true |
Auto-expand columns for sort indicator |
relativeWidthGrowsToFillWidth |
boolean |
true |
Expand relative columns to fill space |
relativeWidthShrinksToFillWidth |
boolean |
false |
Shrink relative columns to fit |
convertColumnWidthsToRelative |
boolean |
false |
Convert auto widths to relative |
autoFillTableWidth |
boolean |
false |
Stretch columns to fill table width |
autoFillLastColumn |
boolean |
true |
Expand the last resizable, non-sticky column to fill leftover width |
resizeAreaWidth |
number |
8 |
Width of resize drag area in pixels |
resizeAreaDoubleClickDuration |
number |
300 |
Duration of double-click event for auto column resize |
autoFitColumnOnResizeDoubleClick |
boolean |
false |
Auto-fit columns on resize-area double click |
{
name: string; // Required: unique identifier
label?: string; // Header text (defaults to name)
width?: number | string; // number (px), '30%', 0.3 (relative), 'auto', or 'rest'
dataPath?: string | string[]; // Path to data (defaults to [name])
comparePath?: string | string[]; // Path for sorting (defaults to dataPath)
resizable?: boolean; // Allow resizing this column (default: true)
sortable?: boolean; // Allow sorting by this column (default: true)
movable?: boolean; // Allow moving this column (default: true)
visible?: boolean; // Column visibility (default: true)
sticky?: 'start' | 'end' | false | null; // Pin to start or end
cellClasses?: string; // Additional CSS classes for cells
ignoreMin?: boolean; // Ignore minColumnWidth for this column
order?: number; // Column order
}By default, if the visible columns do not reach the table edge, the last visible resizable, non-sticky column is expanded as a layout-only fallback, so a fixed-size or sticky trailing column keeps its width. When there is no such column, the last resizable column is used, then the last column. This does not change that column's configured or serialized width. Set autoFillLastColumn: false to opt out.
| Option | Type | Description |
|---|---|---|
cellFormatter |
(value: unknown, columnName: string, rowData: RowData) => string |
Custom cell HTML renderer |
stickyEndRows |
RowData[] |
End rows that flow after the body or stay pinned to the viewport bottom. See Sticky End Rows |
stickyEndRowFormatter |
(value: unknown, columnName: string, rowData: RowData, stickyRowIndex: number) => string |
Cell HTML renderer for the sticky end rows. Falls back to cellFormatter |
stickyEndRowsMode |
'flow' | 'sticky' | 'fixed' |
Placement of the sticky end rows (default 'sticky'). See Sticky End Rows |
headerCellFormatter |
(label: string, columnName: string) => string |
Custom header cell renderer |
filter |
(row: RowData, args: unknown) => boolean |
Custom filter function |
sortedColumns |
(string | ColumnSortOptions)[] |
Initial sort configuration; strings sort ascending. Rows given to setRows() are only sorted with setRows(rows, true). (sortColumn is accepted as a legacy alias.) |
onComparatorRequired |
(columnName: string, descending: boolean, defaultComparator: ComparatorFunction) => ComparatorFunction |
Custom comparator provider |
customSortingProvider |
(data: RowData[], sort: (data: RowData[]) => RowData[]) => RowData[] |
Custom sorting implementation |
| Option | Type | Default | Description |
|---|---|---|---|
tableClassName |
string |
'dgtable' |
Base CSS class for the table |
cellClasses |
string |
'' |
Additional classes for all cells |
resizerClassName |
string |
'dgtable-resize' |
Class for resize handle |
cellPreviewClassName |
string |
'dgtable-cell-preview' |
Class for cell preview |
allowCellPreview |
boolean |
true |
Show preview on hover |
allowHeaderCellPreview |
boolean |
true |
Show preview for headers |
cellPreviewAutoBackground |
boolean |
true |
Match preview background to cell |
resizeAreaWidth |
number |
8 |
Width of resize drag area |
table.render() // Render the table
table.clearAndRender(render=true) // Force full re-rendertable.setColumns(columns, render=true) // Replace all columns
table.addColumn(columnData, before=-1, render) // Add a column
table.removeColumn(columnName, render=true) // Remove a column
table.setColumnLabel(column, label) // Update column label
table.moveColumn(src, dest, visibleOnly=true) // Reorder columns
table.setColumnVisible(column, visible) // Show/hide column
table.isColumnVisible(column) // Check visibility
table.setColumnWidth(column, width) // Set column width
table.getColumnWidth(column) // Get column width
table.autoFitColumn(column) // Fit column to header/content width
table.getColumnConfig(column): ColumnOptions // Get column config
table.getColumnsConfig(): Record<string, ColumnOptions> // Get all columns config, keyed by column nametable.sort(column: string, descending, add=false) // Sort by column
table.resort(render=true) // Re-apply current sort
table.setSortedColumns(columns: SerializedColumnSort[]) // Set current sort state
table.getSortedColumns(): SerializedColumnSort[] // Get current sort state
table.setMaxColumnSortCount(count) // Set max sortable columns
table.getMaxColumnSortCount(): number // Get max sortable columnstable.setRows(data, resort=false) // Replace all rows
table.addRows(data, at=-1, resort=false, render=true) // Add rows
table.removeRow(rowIndex, render=true) // Remove one row
table.removeRows(rowIndex, count, render=true) // Remove multiple rows
table.refreshRow(rowIndex, render=true) // Refresh a row
table.refreshAllVirtualRows() // Refresh all visible rows
table.getRowCount() // Total row count
table.getFilteredRowCount() // Filtered row count
table.getDataForRow(rowIndex) // Get row data by index
table.getDataForFilteredRow(filteredIndex) // Get filtered row data
table.getIndexForRow(rowData) // Find row index
table.getIndexForFilteredRow(rowData) // Find filtered row index
table.getRowElement(rowIndex) // Get row DOM element
table.getRowYPos(rowIndex) // Get row Y positiontable.setStickyEndRows(rows, render=true) // Replace the sticky end rows ([] or null removes them)
table.getStickyEndRows(): RowData[] // Get the sticky end rows
table.getStickyEndRowCount(): number // Get the number of sticky end rows
table.getStickyEndRowElement(index) // Get a sticky end row DOM element
table.refreshStickyEndRows() // Re-create the sticky end row elements
table.refreshStickyEndRow(index) // Re-create one sticky end row element (e.g. totals), keeping the others
table.setStickyEndRowFormatter(fn, render=true) // Set the sticky end row formatter (null falls back to the cell formatter)
table.setStickyEndRowsMode('flow' | 'sticky' | 'fixed') // Set the placement of the end rows
table.getStickyEndRowsMode() // Get the placement of the sticky end rowstable.setFilter(filterFn) // Set custom filter function
table.filter(args) // Apply filter with arguments
table.clearFilter() // Clear active filter
// Built-in filter example:
table.filter({ column: 'name', keyword: 'john', caseSensitive: false });table.setCellFormatter(fn) // Set cell formatter
table.setHeaderCellFormatter(fn) // Set header formatter
table.getHtmlForRowCell(rowIndex, columnName) // Get cell HTML
table.getHtmlForRowDataCell(rowData, columnName) // Get cell HTML from datatable.tableWidthChanged(forceUpdate=false, renderColumns=true) // Notify width change
table.tableHeightChanged() // Notify height change
table.setMinColumnWidth(width) // Set global min width
table.getMinColumnWidth() // Get global min width
table.setMaxStickyColumnRelativeWidth(width) // Set max relative width for sticky columns
table.getMaxStickyColumnRelativeWidth() // Get max relative width for sticky columns
table.setColumnAutoWidthExtraSize(width) // Set extra width added to auto-fit column widths
table.getColumnAutoWidthExtraSize() // Get extra width added to auto-fit column widths
table.setResizeAreaWidth(width) // Set the width of the resize area
table.getResizeAreaWidth() // Get the width of the resize area
table.setResizeAreaDoubleClickDuration(duration) // Set the double-click duration for the resize area
table.getResizeAreaDoubleClickDuration() // Get the double-click duration for the resize areatable.hideCellPreview() // Hide or prevent cell preview
table.abortCellPreview() // Alias for hideCellPreview()table.setMovableColumns(movable) // Enable/disable column moving
table.getMovableColumns() // Get movable state
table.setResizableColumns(resizable) // Enable/disable column resizing
table.getResizableColumns() // Get resizable statetable.setOnComparatorRequired(callback) // Set comparator provider
table.setCustomSortingProvider(provider) // Set custom sort providertable.isWorkerSupported() // Check Web Worker support
table.createWebWorker(url, start=true, resort=false) // Create worker
table.unbindWebWorker(worker) // Unbind worker
table.getUrlForElementContent(elementId) // Create blob URL from elementtable.el // The table wrapper element
table.getHeaderRowElement() // Get header row element// TypeScript users get full autocompletion and type checking!
table.on('rowclick', (data) => {
// data is typed as RowClickEvent
console.log(data.rowIndex, data.rowData);
});
// Custom events are also supported (for using table as event bus)
table.on('my-custom-event', (data) => {
// data is typed as `unknown` by default
console.log(data);
});
// You can specify the type for custom events
table.on<{ customField: string }>('my-typed-event', (data) => {
console.log(data.customField); // TypeScript knows the type
});
table.on(event, handler) // Add event listener (typed for built-in events)
table.once(event, handler) // Add one-time listener (typed)
table.off(event, handler) // Remove listener
table.emit(event, data) // Emit event (typed for built-in events)table.destroy() // Destroy table and free memory
table.close() // Alias for destroy()
table.remove() // Alias for destroy()Subscribe to events using table.on(eventName, handler).
Built-in events have fully typed handlers with autocompletion. You can also use the table's event system as an event bus for your own custom events.
| Event | Data Type | Description |
|---|---|---|
render |
undefined |
Table finished rendering |
renderskeleton |
undefined |
Table structure rebuilt |
| Event | Data Type | Description |
|---|---|---|
rowcreate |
RowCreateEvent |
Row element created |
rowclick |
RowClickEvent |
Row clicked |
rowdestroy |
HTMLElement |
Row element about to be removed |
interface RowCreateEvent {
filteredRowIndex: number; // Index in filtered data
rowIndex: number; // Index in original data
rowEl: HTMLElement; // The row DOM element
rowData: RowData; // The row data object
}
interface RowClickEvent {
event: MouseEvent; // The original mouse event
filteredRowIndex: number; // Index in filtered data
rowIndex: number; // Index in original data
rowEl: HTMLElement; // The row DOM element
rowData: RowData; // The row data object
}| Event | Data Type | Description |
|---|---|---|
stickyendrowcreate |
StickyEndRowCreateEvent |
Sticky end row element created |
stickyendrowclick |
StickyEndRowClickEvent |
Sticky end row clicked |
stickyendrowdestroy |
HTMLElement |
Sticky end row element about to be removed |
interface StickyEndRowCreateEvent {
stickyRowIndex: number; // Index among the sticky end rows
rowEl: HTMLElement; // The row DOM element
rowData: RowData; // The row data object
}
interface StickyEndRowClickEvent {
event: MouseEvent; // The original mouse event
stickyRowIndex: number; // Index among the sticky end rows
rowEl: HTMLElement; // The row DOM element
rowData: RowData; // The row data object
}| Event | Data Type | Description |
|---|---|---|
cellpreview |
CellPreviewEvent |
Cell preview showing |
cellpreviewdestroy |
CellPreviewDestroyEvent |
Cell preview hiding |
cellhoveroverflow |
CellHoverOverflowEvent |
Cell hovered while its content overflows |
cellhoveroverflow fires as soon as overflow is detected on hover, before the built-in preview popup is built or shown — including when allowPreview is false on the column (which otherwise suppresses the popup entirely). Use it as a hook to implement your own overflow UI, such as a custom tooltip, in place of or alongside the built-in preview.
interface CellPreviewEvent {
el: Element | null; // Preview element's first child
name: string; // Column name
rowIndex: number | null; // Row index (null for header and sticky end rows)
rowData: RowData | null; // Row data (null for header)
stickyEndRowIndex: number | null; // Index among the sticky end rows (null otherwise)
cell: HTMLElement; // Original cell element
cellEl: HTMLElement; // Cell's inner element
}
interface CellPreviewDestroyEvent {
el: ChildNode | null; // Preview element's first child
name: string; // Column name
rowIndex: number | null; // Row index (null for header and sticky end rows)
rowData: RowData | null; // Row data (null for header)
stickyEndRowIndex: number | null; // Index among the sticky end rows (null otherwise)
cell: HTMLElement | null; // Original cell element
cellEl: ChildNode | null; // Cell's inner element
}
interface CellHoverOverflowEvent {
name: string; // Column name
rowIndex: number | null; // Row index (null for header and sticky end rows)
rowData: RowData | null; // Row data (null for header)
stickyEndRowIndex: number | null; // Index among the sticky end rows (null otherwise)
cell: HTMLElement; // Original cell element
cellEl: HTMLElement; // Cell's inner element (the element whose content overflows)
}| Event | Data Type | Description |
|---|---|---|
headerrowcreate |
HTMLElement |
Header row created |
headercontextmenu |
HeaderContextMenuEvent |
Header right-click |
interface HeaderContextMenuEvent {
columnName: string; // Column that was right-clicked
pageX: number; // Mouse X position
pageY: number; // Mouse Y position
bounds: { // Cell bounds
left: number;
top: number;
width: number;
height: number;
};
}| Event | Data Type | Description |
|---|---|---|
addcolumn |
string |
Column name added |
removecolumn |
string |
Column name removed |
movecolumn |
MoveColumnEvent |
Column moved |
showcolumn |
string |
Column name shown |
hidecolumn |
string |
Column name hidden |
columnwidth |
ColumnWidthEvent |
Column resized |
columnresizeareadoubleclick |
ColumnResizeAreaDoubleClickEvent |
Resize area double-clicked |
interface MoveColumnEvent {
name: string; // Column name
src: number; // Original order position
dest: number; // New order position
}
interface ColumnWidthEvent {
name: string; // Column name
width: number | string; // New width
oldWidth: number | string; // Previous width
}
interface ColumnResizeAreaDoubleClickEvent {
name: string; // Column name
columnName: string; // Column name
event: Event; // Original mouse/touch/double-click event
}| Event | Data Type | Description |
|---|---|---|
addrows |
AddRowsEvent |
Rows added |
sort |
SortEvent |
Data sorted |
filter |
unknown |
Filter applied (filter args) |
filterclear |
{} |
Filter cleared |
interface AddRowsEvent {
count: number; // Number of rows added
clear: boolean; // Whether table was cleared first
}
interface SortEvent {
sorts: SerializedColumnSort[]; // Current sort state
resort?: boolean; // True if re-sorting existing data
}// Row click handler
table.on('rowclick', (data) => {
console.log('Clicked row:', data.rowIndex, data.rowData);
});
// Column resize handler
table.on('columnwidth', (data) => {
console.log(`Column ${data.name} resized from ${data.oldWidth} to ${data.width}`);
});
// Sort handler
table.on('sort', (data) => {
console.log('Sorted by:', data.sorts);
});
// Cell preview handler
table.on('cellpreview', (data) => {
// Customize preview content
if (data.el) {
data.el.innerHTML += '<span class="custom-badge">Preview</span>';
}
});
// Cell hover with overflow handler - fires before the built-in preview is
// generated, so it's a good place to show your own tooltip instead
table.on('cellhoveroverflow', (data) => {
showCustomTooltip(data.cell, data.rowData);
});End rows can flow after the body or stay pinned to the bottom of the table viewport, for things like totals, averages, or controls such as per-column filter inputs. They:
- Are separate from the table data: never sorted, filtered or virtualized, and not counted by
row indices,
getRowCount()or therowcreate/rowclick/rowdestroyevents (they havestickyendrowcreate/stickyendrowclick/stickyendrowdestroyinstead). - Use the same columns as the body: widths, order, visibility, sticky columns and RTL all apply, and they scroll horizontally with the body.
- Have three placement modes (
stickyEndRowsMode):'flow': right after the last body row, scrolling vertically with the body. Use this for totals that should only appear after scrolling to the end.'sticky'(default): right after the last body row, sticking to the bottom of the viewport when the body is taller than it.'fixed': always at the bottom of the viewport, with empty space above them when the body rows do not fill it. It works by giving the body a minimum height of "viewport height minus the rows' height", tracked with aResizeObserver. It needs a tableheight; without one it lays out like'sticky'.
- Are rendered inside the scroll element, in a
.dgtable-sticky-end-rowscontainer right after.dgtable-body, withposition: sticky; bottom: 0in the pinned modes andposition: relativein'flow'mode. Each row has thedgtable-rowanddgtable-sticky-end-rowclasses, so style them through those. The container getsz-index: 1unless your stylesheet gives it one. - Are kept across renders: changing, sorting or filtering the data, resizing or scrolling only
updates their layout, so controls in them keep their value and focus. They are re-created
(with
stickyendrowdestroy/stickyendrowcreate) only bysetStickyEndRows(),refreshStickyEndRows(),refreshStickyEndRow(index)(that row only),setStickyEndRowFormatter(),setColumns(), adding, removing, showing or hiding columns, moving columns in a virtual table, andsetCellFormatter()when they have nostickyEndRowFormatterof their own. Bind control listeners instickyendrowcreate. - Get no cell preview on cells that contain controls (
input,select,textarea,buttonorcontenteditable), since the preview would be a copy of them covering the real ones.cellhoveroverflowstill fires for those cells. - To keep a totals row up to date next to a row of controls, refresh just the totals row with
refreshStickyEndRow(index), so the controls' row is left alone.
// Sums a column over the rows that pass the current filter
const sum = (table, column) => {
let total = 0;
for (let i = 0; i < table.getFilteredRowCount(); i++)
total += Number(table.getDataForFilteredRow(i)[column]) || 0;
return total;
};
const table = new DGTable({
columns: [
{ name: 'product' },
{ name: 'qty', width: 80 },
{ name: 'price', width: 100 },
],
height: 400,
stickyEndRows: [{ product: 'Total' }], // index 0
stickyEndRowFormatter: (value, columnName) => {
if (columnName === 'qty')
return String(sum(table, 'qty'));
return value == null ? '' : String(value);
},
});
// Recompute the totals whenever the data or the filter changes
for (const event of ['addrows', 'filter', 'filterclear'])
table.on(event, () => table.refreshStickyEndRow(0));
// Switch placement without moving totals into or out of the body data
table.setStickyEndRowsMode('flow');
table.setStickyEndRowsMode('sticky');
table.setStickyEndRowsMode('fixed');
// removeRows(), removeRow() and refreshRow() emit no event: refresh after calling them
table.removeRow(3);
table.refreshStickyEndRow(0);The library exports the following types for TypeScript users:
import type {
// Configuration types
DGTableOptions, // Constructor options
ColumnOptions, // Column definition
ColumnSortOptions, // Sort specification { column, descending? }
SerializedColumnSort, // Saved sort config
RowData, // Row data (Record<string, unknown>)
// Function types
CellFormatter, // Cell formatter function
StickyEndRowFormatter, // Sticky end row cell formatter function
StickyEndRowsMode, // 'flow' | 'sticky' | 'fixed'
HeaderCellFormatter, // Header cell formatter function
FilterFunction, // Filter function
ComparatorFunction, // Row comparator function
OnComparatorRequired, // Comparator provider callback
CustomSortingProvider, // Custom sorting function
// Event types
RowCreateEvent, // 'rowcreate' event data
RowClickEvent, // 'rowclick' event data
CellPreviewEvent, // 'cellpreview' event data
CellPreviewDestroyEvent, // 'cellpreviewdestroy' event data
CellHoverOverflowEvent, // 'cellhoveroverflow' event data
HeaderContextMenuEvent, // 'headercontextmenu' event data
MoveColumnEvent, // 'movecolumn' event data
ColumnWidthEvent, // 'columnwidth' event data
ColumnResizeAreaDoubleClickEvent, // 'columnresizeareadoubleclick' event data
AddRowsEvent, // 'addrows' event data
SortEvent, // 'sort' event data
StickyEndRowCreateEvent, // 'stickyendrowcreate' event data
StickyEndRowClickEvent, // 'stickyendrowclick' event data
// Event map (for advanced typing)
DGTableEventMap, // Maps event names to their data types
} from '@danielgindi/dgtable.js';The DGTableEventMap interface provides full autocompletion when using .on(), .once(), .off(), and .emit():
// Event names autocomplete, and handler receives correctly typed data
table.on('rowclick', (data) => {
// TypeScript knows: data.event, data.rowIndex, data.rowData, etc.
console.log(`Clicked row ${data.rowIndex}`);
});
table.on('columnwidth', (data) => {
// TypeScript knows: data.name, data.width, data.oldWidth
console.log(`Column ${data.name} resized to ${data.width}px`);
});# Install dependencies
npm install
# Build
npm run build
# Lint
npm run lintTests run with Vitest: pure modules in Node, everything else in real browsers through Playwright.
# One-time: download the browsers
npx playwright install chromium firefox webkit
npm test # unit + browser (Chromium, Firefox, WebKit) + type tests
npm run test:watch # watch mode
npm run test:coverage # coverage report (Chromium)
npm run test:dist # build, then test the bundles and the npm package contents
npm run test:perf # performance and leak checks (Chromium)
# Limit the browsers
TEST_BROWSERS=chromium npm run test:browserDaniel Cohen Gindi - danielgindi@gmail.com
Contributions are welcome! Please feel free to:
- Report bugs and issues
- Submit pull requests
- Improve documentation
- Share your use cases
MIT License - see LICENSE for details.
Copyright (c) 2013-present Daniel Cohen Gindi