package table

Import Path
	github.com/jedib0t/go-pretty/v6/table (on go.dev)

Dependency Relation
	imports 9 packages, and imported by one package

Involved Source Files

	      config.go
	      render.go
	      render_csv.go
	      render_html.go
	      render_markdown.go
	      sort.go
	      style.go
	      table.go
	      util.go
	      writer.go
Package-Level Type Names (total 19, in which 16 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type BoxStyle (struct)
		BoxStyle defines the characters/strings to use to render the borders and
		separators for the Table.

		Fields (total 18, all are exported)
			BottomLeft string
			BottomRight string
			BottomSeparator string
			EmptySeparator string
			Left string
			LeftSeparator string
			MiddleHorizontal string
			MiddleSeparator string
			MiddleVertical string
			PaddingLeft string
			PaddingRight string
			PageSeparator string
			Right string
			RightSeparator string
			TopLeft string
			TopRight string
			TopSeparator string
			UnfinishedRow string
		As Types Of (total 6, in which 5 are exported)
			  var StyleBoxBold
			  var StyleBoxDefault
			  var StyleBoxDouble
			  var StyleBoxLight
			  var StyleBoxRounded
			/* one unexported ... *//* one unexported: */
			  var styleBoxTest

	 type ColorOptions (struct)
		ColorOptions defines the ANSI colors to use for parts of the Table.

		Fields (total 5, all are exported)
			Footer text.Colors
				// footer row(s) colors

			Header text.Colors
				// header row(s) colors

			IndexColumn text.Colors
				// index-column colors (row #, etc.)

			Row text.Colors
				// regular row(s) colors

			RowAlternate text.Colors
				// regular row(s) colors for the even-numbered rows

		As Types Of (total 15, all are exported)
			  var ColorOptionsBlackOnBlueWhite
			  var ColorOptionsBlackOnCyanWhite
			  var ColorOptionsBlackOnGreenWhite
			  var ColorOptionsBlackOnMagentaWhite
			  var ColorOptionsBlackOnRedWhite
			  var ColorOptionsBlackOnYellowWhite
			  var ColorOptionsBlueWhiteOnBlack
			  var ColorOptionsBright
			  var ColorOptionsCyanWhiteOnBlack
			  var ColorOptionsDark
			  var ColorOptionsDefault
			  var ColorOptionsGreenWhiteOnBlack
			  var ColorOptionsMagentaWhiteOnBlack
			  var ColorOptionsRedWhiteOnBlack
			  var ColorOptionsYellowWhiteOnBlack

	 type ColumnConfig (struct)
		ColumnConfig contains configurations that determine and modify the way the
		contents of the column get rendered.

		Fields (total 19, all are exported)
			Align text.Align
				Align defines the horizontal alignment

			AlignFooter text.Align
				AlignFooter defines the horizontal alignment of Footer rows

			AlignHeader text.Align
				AlignHeader defines the horizontal alignment of Header rows

			AutoMerge bool
				AutoMerge merges cells with similar values and prevents separators from
				being drawn. Caveats:
				* VAlign is applied on the individual cell and not on the merged cell
				* Does not work in CSV/HTML/Markdown render modes
				* Does not work well with horizontal auto-merge (RowConfig.AutoMerge)

				Works best when:
				* Style().Options.SeparateRows == true
				* Style().Color.Row == Style().Color.RowAlternate (or not set)

			Colors text.Colors
				Colors defines the colors to be used on the column

			ColorsFooter text.Colors
				ColorsFooter defines the colors to be used on the column in Footer rows

			ColorsHeader text.Colors
				ColorsHeader defines the colors to be used on the column in Header rows

			Hidden bool
				Hidden when set to true will prevent the column from being rendered.
				This is useful in cases like needing a column for sorting, but not for
				display.

			Name string
				Name is the name of the Column as it appears in the first Header row.
				If a Header is not provided, or the name is not found in the header, this
				will not work.

			Number int
				Number is the Column # from left. When specified, it overrides the Name
				property. If you know the exact Column number, use this instead of Name.

			Transformer text.Transformer
				Transformer is a custom-function that changes the way the value gets
				rendered to the console. Refer to text/transformer.go for ready-to-use
				Transformer functions.

			TransformerFooter text.Transformer
				TransformerFooter is like Transformer but for Footer rows

			TransformerHeader text.Transformer
				TransformerHeader is like Transformer but for Header rows

			VAlign text.VAlign
				VAlign defines the vertical alignment

			VAlignFooter text.VAlign
				VAlignFooter defines the vertical alignment in Footer rows

			VAlignHeader text.VAlign
				VAlignHeader defines the vertical alignment in Header rows

			WidthMax int
				WidthMax defines the maximum character length of the column

			WidthMaxEnforcer WidthEnforcer
				WidthEnforcer enforces the WidthMax value on the column contents;
				default: text.WrapText

			WidthMin int
				WidthMin defines the minimum character length of the column

		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			( T) getWidthMaxEnforcer() WidthEnforcer
		As Inputs Of (at least 2, both are exported)
			func (*Table).SetColumnConfigs(configs []ColumnConfig)
			func Writer.SetColumnConfigs(configs []ColumnConfig)

	 type FormatOptions (struct)
		FormatOptions defines the text-formatting to perform on parts of the Table.

		Fields (total 3, all are exported)
			Footer text.Format
				// footer row(s) text format

			Header text.Format
				// header row(s) text format

			Row text.Format
				// (data) row(s) text format

		As Types Of (only one, which is exported)
			  var FormatOptionsDefault

	 type HTMLOptions (struct)
		HTMLOptions defines the global options to control HTML rendering.

		Fields (total 4, all are exported)
			CSSClass string
				// CSS class to set on the overall <table> tag

			EmptyColumn string
				// string to replace "" columns with (entire content being "")

			EscapeText bool
				// escape text into HTML-safe content?

			Newline string
				// string to replace "\n" characters with

		As Types Of (only one, which is exported)
			  var DefaultHTMLOptions

	 type Options (struct)
		Options defines the global options that determine how the Table is
		rendered.

		Fields (total 5, all are exported)
			DrawBorder bool
				DrawBorder enables or disables drawing the border around the Table.
				Example of a table where it is disabled:
				    # │ FIRST NAME │ LAST NAME │ SALARY │
				 ─────┼────────────┼───────────┼────────┼─────────────────────────────
				    1 │ Arya       │ Stark     │   3000 │
				   20 │ Jon        │ Snow      │   2000 │ You know nothing, Jon Snow!
				  300 │ Tyrion     │ Lannister │   5000 │
				 ─────┼────────────┼───────────┼────────┼─────────────────────────────
				      │            │ TOTAL     │  10000 │

			SeparateColumns bool
				SeparateColumns enables or disable drawing border between columns.
				Example of a table where it is disabled:
				 ┌─────────────────────────────────────────────────────────────────┐
				 │   #  FIRST NAME  LAST NAME  SALARY                              │
				 ├─────────────────────────────────────────────────────────────────┤
				 │   1  Arya        Stark        3000                              │
				 │  20  Jon         Snow         2000  You know nothing, Jon Snow! │
				 │ 300  Tyrion      Lannister    5000                              │
				 │                  TOTAL       10000                              │
				 └─────────────────────────────────────────────────────────────────┘

			SeparateFooter bool
				SeparateFooter enables or disable drawing border between the footer and
				the rows. Example of a table where it is disabled:
				 ┌─────┬────────────┬───────────┬────────┬─────────────────────────────┐
				 │   # │ FIRST NAME │ LAST NAME │ SALARY │                             │
				 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
				 │   1 │ Arya       │ Stark     │   3000 │                             │
				 │  20 │ Jon        │ Snow      │   2000 │ You know nothing, Jon Snow! │
				 │ 300 │ Tyrion     │ Lannister │   5000 │                             │
				 │     │            │ TOTAL     │  10000 │                             │
				 └─────┴────────────┴───────────┴────────┴─────────────────────────────┘

			SeparateHeader bool
				SeparateHeader enables or disable drawing border between the header and
				the rows. Example of a table where it is disabled:
				 ┌─────┬────────────┬───────────┬────────┬─────────────────────────────┐
				 │   # │ FIRST NAME │ LAST NAME │ SALARY │                             │
				 │   1 │ Arya       │ Stark     │   3000 │                             │
				 │  20 │ Jon        │ Snow      │   2000 │ You know nothing, Jon Snow! │
				 │ 300 │ Tyrion     │ Lannister │   5000 │                             │
				 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
				 │     │            │ TOTAL     │  10000 │                             │
				 └─────┴────────────┴───────────┴────────┴─────────────────────────────┘

			SeparateRows bool
				SeparateRows enables or disables drawing separators between each row.
				Example of a table where it is enabled:
				 ┌─────┬────────────┬───────────┬────────┬─────────────────────────────┐
				 │   # │ FIRST NAME │ LAST NAME │ SALARY │                             │
				 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
				 │   1 │ Arya       │ Stark     │   3000 │                             │
				 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
				 │  20 │ Jon        │ Snow      │   2000 │ You know nothing, Jon Snow! │
				 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
				 │ 300 │ Tyrion     │ Lannister │   5000 │                             │
				 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
				 │     │            │ TOTAL     │  10000 │                             │
				 └─────┴────────────┴───────────┴────────┴─────────────────────────────┘

		As Types Of (total 3, all are exported)
			  var OptionsDefault
			  var OptionsNoBorders
			  var OptionsNoBordersAndSeparators

	 type Row ([]T)
		Row defines a single row in the Table.

		As Inputs Of (at least 10, in which 8 are exported)
			func (*Table).AppendFooter(row Row, config ...RowConfig)
			func (*Table).AppendHeader(row Row, config ...RowConfig)
			func (*Table).AppendRow(row Row, config ...RowConfig)
			func (*Table).AppendRows(rows []Row, config ...RowConfig)
			func Writer.AppendFooter(row Row, configs ...RowConfig)
			func Writer.AppendHeader(row Row, configs ...RowConfig)
			func Writer.AppendRow(row Row, configs ...RowConfig)
			func Writer.AppendRows(rows []Row, configs ...RowConfig)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func (*Table).analyzeAndStringify(row Row, hint renderHint) rowStr
			func (*Table).initForRenderRowsStringify(rows []Row, hint renderHint) []rowStr

	 type RowConfig (struct)
		RowConfig contains configurations that determine and modify the way the
		contents of a row get rendered.

		Fields (only one, which is exported)
			AutoMerge bool
				AutoMerge merges cells with similar values and prevents separators from
				being drawn. Caveats:
				* Align is overridden to text.AlignCenter on the merged cell
				* Does not work in CSV/HTML/Markdown render modes
				* Does not work well with vertical auto-merge (ColumnConfig.AutoMerge)

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Table).getRowConfig(hint renderHint) RowConfig
		As Inputs Of (at least 8, all are exported)
			func (*Table).AppendFooter(row Row, config ...RowConfig)
			func (*Table).AppendHeader(row Row, config ...RowConfig)
			func (*Table).AppendRow(row Row, config ...RowConfig)
			func (*Table).AppendRows(rows []Row, config ...RowConfig)
			func Writer.AppendFooter(row Row, configs ...RowConfig)
			func Writer.AppendHeader(row Row, configs ...RowConfig)
			func Writer.AppendRow(row Row, configs ...RowConfig)
			func Writer.AppendRows(rows []Row, configs ...RowConfig)

	 type RowPainter (func)
		RowPainter is a custom function that takes a Row as input and returns the
		text.Colors{} to use on the entire row

		As Inputs Of (at least 2, both are exported)
			func (*Table).SetRowPainter(painter RowPainter)
			func Writer.SetRowPainter(painter RowPainter)

	 type SortBy (struct)
		SortBy defines What to sort (Column Name or Number), and How to sort (Mode).

		Fields (total 3, all are exported)
			Mode SortMode
				Mode tells the Writer how to Sort. Asc/Dsc/etc.

			Name string
				Name is the name of the Column as it appears in the first Header row.
				If a Header is not provided, or the name is not found in the header, this
				will not work.

			Number int
				Number is the Column # from left. When specified, it overrides the Name
				property. If you know the exact Column number, use this instead of Name.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Table).parseSortBy(sortBy []SortBy) []SortBy
		As Inputs Of (at least 3, in which 2 are exported)
			func (*Table).SortBy(sortBy []SortBy)
			func Writer.SortBy(sortBy []SortBy)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Table).parseSortBy(sortBy []SortBy) []SortBy

	 type SortMode int (basic type)
		SortMode defines How to sort.

		As Types Of (total 4, all are exported)
			const Asc
			const AscNumeric
			const Dsc
			const DscNumeric

	 type Style (struct)
		Style declares how to render the Table and provides very fine-grained control
		on how the Table gets rendered on the Console.

		Fields (total 7, all are exported)
			Box BoxStyle
				// characters to use for the boxes

			Color ColorOptions
				// colors to use for the rows and columns

			Format FormatOptions
				// formatting options for the rows and columns

			HTML HTMLOptions
				// rendering options for HTML mode

			Name string
				// name of the Style

			Options Options
				// misc. options for the table

			Title TitleOptions
				// formation options for the title text

		As Outputs Of (at least 2, both are exported)
			func (*Table).Style() *Style
			func Writer.Style() *Style
		As Inputs Of (at least 2, both are exported)
			func (*Table).SetStyle(style Style)
			func Writer.SetStyle(style Style)
		As Types Of (total 20, in which 19 are exported)
			  var StyleBold
			  var StyleColoredBlackOnBlueWhite
			  var StyleColoredBlackOnCyanWhite
			  var StyleColoredBlackOnGreenWhite
			  var StyleColoredBlackOnMagentaWhite
			  var StyleColoredBlackOnRedWhite
			  var StyleColoredBlackOnYellowWhite
			  var StyleColoredBlueWhiteOnBlack
			  var StyleColoredBright
			  var StyleColoredCyanWhiteOnBlack
			  var StyleColoredDark
			  var StyleColoredGreenWhiteOnBlack
			  var StyleColoredMagentaWhiteOnBlack
			  var StyleColoredRedWhiteOnBlack
			  var StyleColoredYellowWhiteOnBlack
			  var StyleDefault
			  var StyleDouble
			  var StyleLight
			  var StyleRounded
			/* one unexported ... *//* one unexported: */
			  var styleTest

	 type Table (struct)
		Table helps print a 2-dimensional array in a human readable pretty-table.

		Fields (total 32, none are exported)
			/* 32 unexporteds ... *//* 32 unexporteds: */
			allowedRowLength int
				allowedRowLength is the max allowed length for a row (or line of output)

			autoIndex bool
				enable automatic indexing of the rows and columns like a spreadsheet?

			autoIndexVIndexMaxLength int
				autoIndexVIndexMaxLength denotes the length in chars for the last rownum

			caption string
				caption stores the text to be rendered just below the table; and doesn't
				get used when rendered as a CSV

			columnConfigMap map[int]ColumnConfig
				columnConfigMap stores the custom-configuration by column
				number and is generated before rendering

			columnConfigs []ColumnConfig
				columnConfigs stores the custom-configuration for 1 or more columns

			columnIsNonNumeric []bool
				columnIsNonNumeric stores if a column contains non-numbers in all rows

			htmlCSSClass string
				htmlCSSClass stores the HTML CSS Class to use on the <table> node

			indexColumn int
				indexColumn stores the number of the column considered as the "index"

			maxColumnLengths []int
				maxColumnLengths stores the length of the longest line in each column

			maxRowLength int
				maxRowLength stores the length of the longest row

			numColumns int
				numColumns stores the (max.) number of columns seen

			numLinesRendered int
				numLinesRendered keeps track of the number of lines rendered and helps in
				paginating long tables

			outputMirror io.Writer
				outputMirror stores an io.Writer where the "Render" functions would write

			pageSize int
				pageSize stores the maximum lines to render before rendering the header
				again (to denote a page break) - useful when you are dealing with really
				long tables

			rowPainter RowPainter
				rowPainter is a custom function that given a Row, returns the colors to
				use on the entire row

			rowSeparator rowStr
				rowSeparator is a dummy row that contains the separator columns (dashes
				that make up the separator between header/body/footer

			rows []rowStr
				rows stores the rows that make up the body (in string form)

			rowsColors []text.Colors
				rowsColors stores the text.Colors over-rides for each row as defined by
				rowPainter

			rowsConfigMap map[int]RowConfig
				rowsConfigs stores RowConfig for each row

			rowsFooter []rowStr
				rowsFooter stores the rows that make up the footer (in string form)

			rowsFooterConfigMap map[int]RowConfig
				rowsFooterConfigs stores RowConfig for each footer row

			rowsFooterRaw []Row
				rowsFooterRaw stores the rows that make up the footer

			rowsHeader []rowStr
				rowsHeader stores the rows that make up the header (in string form)

			rowsHeaderConfigMap map[int]RowConfig
				rowsHeaderConfigs stores RowConfig for each header row

			rowsHeaderRaw []Row
				rowsHeaderRaw stores the rows that make up the header

			rowsRaw []Row
				rowsRaw stores the rows that make up the body

			separators map[int]bool
				separators is used to keep track of all rowIndices after which a
				separator has to be rendered

			sortBy []SortBy
				sortBy stores a map of Column

			style *Style
				style contains all the strings used to draw the table, and more

			suppressEmptyColumns bool
				suppressEmptyColumns hides columns which have no content on all regular
				rows

			title string
				title contains the text to appear above the table

		Methods (total 94, in which 27 are exported)
			(*T) AppendFooter(row Row, config ...RowConfig)
				AppendFooter appends the row to the List of footers to render.

				Only the first item in the "config" will be tagged against this row.

			(*T) AppendHeader(row Row, config ...RowConfig)
				AppendHeader appends the row to the List of headers to render.

				Only the first item in the "config" will be tagged against this row.

			(*T) AppendRow(row Row, config ...RowConfig)
				AppendRow appends the row to the List of rows to render.

				Only the first item in the "config" will be tagged against this row.

			(*T) AppendRows(rows []Row, config ...RowConfig)
				AppendRows appends the rows to the List of rows to render.

				Only the first item in the "config" will be tagged against all the rows.

			(*T) AppendSeparator()
				AppendSeparator helps render a separator row after the current last row. You
				could call this function over and over, but it will be a no-op unless you
				call AppendRow or AppendRows in between. Likewise, if the last thing you
				append is a separator, it will not be rendered in addition to the usual table
				separator.

				******************************************************************************
				Please note the following caveats:
				1. SetPageSize(): this may end up creating consecutive separator rows near
				   the end of a page or at the beginning of a page
				2. SortBy(): since SortBy could inherently alter the ordering of rows, the
				   separators may not appear after the row it was originally intended to
				   follow
				******************************************************************************

			(*T) Length() int
				Length returns the number of rows to be rendered.

			(*T) Render() string
				Render renders the Table in a human-readable "pretty" format. Example:
				 ┌─────┬────────────┬───────────┬────────┬─────────────────────────────┐
				 │   # │ FIRST NAME │ LAST NAME │ SALARY │                             │
				 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
				 │   1 │ Arya       │ Stark     │   3000 │                             │
				 │  20 │ Jon        │ Snow      │   2000 │ You know nothing, Jon Snow! │
				 │ 300 │ Tyrion     │ Lannister │   5000 │                             │
				 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
				 │     │            │ TOTAL     │  10000 │                             │
				 └─────┴────────────┴───────────┴────────┴─────────────────────────────┘

			(*T) RenderCSV() string
				RenderCSV renders the Table in CSV format. Example:
				 #,First Name,Last Name,Salary,
				 1,Arya,Stark,3000,
				 20,Jon,Snow,2000,"You know nothing\, Jon Snow!"
				 300,Tyrion,Lannister,5000,
				 ,,Total,10000,

			(*T) RenderHTML() string
				RenderHTML renders the Table in HTML format. Example:
				 <table class="go-pretty-table">
				   <thead>
				   <tr>
				     <th align="right">#</th>
				     <th>First Name</th>
				     <th>Last Name</th>
				     <th align="right">Salary</th>
				     <th>&nbsp;</th>
				   </tr>
				   </thead>
				   <tbody>
				   <tr>
				     <td align="right">1</td>
				     <td>Arya</td>
				     <td>Stark</td>
				     <td align="right">3000</td>
				     <td>&nbsp;</td>
				   </tr>
				   <tr>
				     <td align="right">20</td>
				     <td>Jon</td>
				     <td>Snow</td>
				     <td align="right">2000</td>
				     <td>You know nothing, Jon Snow!</td>
				   </tr>
				   <tr>
				     <td align="right">300</td>
				     <td>Tyrion</td>
				     <td>Lannister</td>
				     <td align="right">5000</td>
				     <td>&nbsp;</td>
				   </tr>
				   </tbody>
				   <tfoot>
				   <tr>
				     <td align="right">&nbsp;</td>
				     <td>&nbsp;</td>
				     <td>Total</td>
				     <td align="right">10000</td>
				     <td>&nbsp;</td>
				   </tr>
				   </tfoot>
				 </table>

			(*T) RenderMarkdown() string
				RenderMarkdown renders the Table in Markdown format. Example:
				 | # | First Name | Last Name | Salary |  |
				 | ---:| --- | --- | ---:| --- |
				 | 1 | Arya | Stark | 3000 |  |
				 | 20 | Jon | Snow | 2000 | You know nothing, Jon Snow! |
				 | 300 | Tyrion | Lannister | 5000 |  |
				 |  |  | Total | 10000 |  |

			(*T) ResetFooters()
				ResetFooters resets and clears all the Footer rows appended earlier.

			(*T) ResetHeaders()
				ResetHeaders resets and clears all the Header rows appended earlier.

			(*T) ResetRows()
				ResetRows resets and clears all the rows appended earlier.

			(*T) SetAllowedRowLength(length int)
				SetAllowedRowLength sets the maximum allowed length or a row (or line of
				output) when rendered as a table. Rows that are longer than this limit will
				be "snipped" to the length. Length has to be a positive value to take effect.

			(*T) SetAutoIndex(autoIndex bool)
				SetAutoIndex adds a generated header with columns such as "A", "B", "C", etc.
				and a leading column with the row number similar to what you'd see on any
				spreadsheet application. NOTE: Appending a Header will void this
				functionality.

			(*T) SetCaption(format string, a ...interface{})
				SetCaption sets the text to be rendered just below the table. This will not
				show up when the Table is rendered as a CSV.

			(*T) SetColumnConfigs(configs []ColumnConfig)
				SetColumnConfigs sets the configs for each Column.

			(*T) SetHTMLCSSClass(cssClass string)
				SetHTMLCSSClass sets the the HTML CSS Class to use on the <table> node
				when rendering the Table in HTML format.

				Deprecated: in favor of Style().HTML.CSSClass

			(*T) SetIndexColumn(colNum int)
				SetIndexColumn sets the given Column # as the column that has the row
				"Number". Valid values range from 1 to N. Note that this is not 0-indexed.

			(*T) SetOutputMirror(mirror io.Writer)
				SetOutputMirror sets an io.Writer for all the Render functions to "Write" to
				in addition to returning a string.

			(*T) SetPageSize(numLines int)
				SetPageSize sets the maximum number of lines to render before rendering the
				header rows again. This can be useful when dealing with tables containing a
				long list of rows that can span pages. Please note that the pagination logic
				will not consider Header/Footer lines for paging.

			(*T) SetRowPainter(painter RowPainter)
				SetRowPainter sets the RowPainter function which determines the colors to use
				on a row. Before rendering, this function is invoked on all rows and the
				color of each row is determined. This color takes precedence over other ways
				to set color (ColumnConfig.Color*, SetColor*()).

			(*T) SetStyle(style Style)
				SetStyle overrides the DefaultStyle with the provided one.

			(*T) SetTitle(format string, a ...interface{})
				SetTitle sets the title text to be rendered above the table.

			(*T) SortBy(sortBy []SortBy)
				SortBy sets the rules for sorting the Rows in the order specified. i.e., the
				first SortBy instruction takes precedence over the second and so on. Any
				duplicate instructions on the same column will be discarded while sorting.

			(*T) Style() *Style
				Style returns the current style.

			(*T) SuppressEmptyColumns()
				SuppressEmptyColumns hides columns when the column is empty in ALL the
				regular rows.

			/* 67 unexporteds ... *//* 67 unexporteds: */
			(*T) analyzeAndStringify(row Row, hint renderHint) rowStr
			(*T) csvFixCommas(str string) string
			(*T) csvFixDoubleQuotes(str string) string
			(*T) csvRenderRow(out *strings.Builder, row rowStr, hint renderHint)
			(*T) csvRenderRows(out *strings.Builder, rows []rowStr, hint renderHint)
			(*T) getAlign(colIdx int, hint renderHint) text.Align
			(*T) getAutoIndexColumnIDs() rowStr
			(*T) getBorderColors(hint renderHint) text.Colors
			(*T) getColumnColors(colIdx int, hint renderHint) text.Colors
			(*T) getColumnSeparator(row rowStr, colIdx int, hint renderHint) string
			(*T) getColumnSeparatorNonBorder(mergeCellsAbove bool, mergeCellsBelow bool, colIdx int, hint renderHint) string
			(*T) getColumnSeparatorNonBorderAutoIndex(mergeNextCol bool, hint renderHint) string
			(*T) getColumnSeparatorNonBorderNonAutoIndex(mergeCellsAbove bool, mergeCellsBelow bool, mergeCurrCol bool, mergeNextCol bool) string
			(*T) getColumnTransformer(colIdx int, hint renderHint) text.Transformer
			(*T) getColumnWidthMax(colIdx int) int
			(*T) getColumnWidthMin(colIdx int) int
			(*T) getFormat(hint renderHint) text.Format
			(*T) getRow(rowIdx int, hint renderHint) rowStr
			(*T) getRowConfig(hint renderHint) RowConfig
			(*T) getSeparatorColors(hint renderHint) text.Colors
			(*T) getSortedRowIndices() []int
				getSortedRowIndices sorts and returns the row indices in Sorted order as
				directed by Table.sortBy which can be set using Table.SortBy(...)

			(*T) getVAlign(colIdx int, hint renderHint) text.VAlign
			(*T) htmlRenderCaption(out *strings.Builder)
			(*T) htmlRenderColumnAttributes(out *strings.Builder, row rowStr, colIdx int, hint renderHint)
			(*T) htmlRenderColumnAutoIndex(out *strings.Builder, hint renderHint)
			(*T) htmlRenderRow(out *strings.Builder, row rowStr, hint renderHint)
			(*T) htmlRenderRows(out *strings.Builder, rows []rowStr, hint renderHint)
			(*T) htmlRenderRowsFooter(out *strings.Builder)
			(*T) htmlRenderRowsHeader(out *strings.Builder)
			(*T) htmlRenderTitle(out *strings.Builder)
			(*T) initForRender()
			(*T) initForRenderColumnConfigs()
			(*T) initForRenderColumnLengths()
			(*T) initForRenderHideColumns()
			(*T) initForRenderRowSeparator()
			(*T) initForRenderRows()
			(*T) initForRenderRowsStringify(rows []Row, hint renderHint) []rowStr
			(*T) initForRenderSortRows()
			(*T) initForRenderSuppressColumns()
			(*T) isIndexColumn(colIdx int, hint renderHint) bool
			(*T) markdownRenderCaption(out *strings.Builder)
			(*T) markdownRenderRow(out *strings.Builder, row rowStr, hint renderHint)
			(*T) markdownRenderRows(out *strings.Builder, rows []rowStr, hint renderHint)
			(*T) markdownRenderRowsFooter(out *strings.Builder)
			(*T) markdownRenderRowsHeader(out *strings.Builder)
			(*T) markdownRenderTitle(out *strings.Builder)
			(*T) parseSortBy(sortBy []SortBy) []SortBy
			(*T) render(out *strings.Builder) string
			(*T) renderColumn(out *strings.Builder, row rowStr, colIdx int, maxColumnLength int, hint renderHint) int
			(*T) renderColumnAutoIndex(out *strings.Builder, hint renderHint)
			(*T) renderColumnColorized(out *strings.Builder, colIdx int, colStr string, hint renderHint)
			(*T) renderColumnSeparator(out *strings.Builder, row rowStr, colIdx int, hint renderHint)
			(*T) renderLine(out *strings.Builder, row rowStr, hint renderHint)
			(*T) renderMarginLeft(out *strings.Builder, hint renderHint)
			(*T) renderMarginRight(out *strings.Builder, hint renderHint)
			(*T) renderRow(out *strings.Builder, row rowStr, hint renderHint)
			(*T) renderRowSeparator(out *strings.Builder, hint renderHint)
			(*T) renderRows(out *strings.Builder, rows []rowStr, hint renderHint)
			(*T) renderRowsBorderBottom(out *strings.Builder)
			(*T) renderRowsBorderTop(out *strings.Builder)
			(*T) renderRowsFooter(out *strings.Builder)
			(*T) renderRowsHeader(out *strings.Builder)
			(*T) renderTitle(out *strings.Builder)
			(*T) reset()
			(*T) shouldMergeCellsHorizontallyAbove(row rowStr, colIdx int, hint renderHint) bool
			(*T) shouldMergeCellsHorizontallyBelow(row rowStr, colIdx int, hint renderHint) bool
			(*T) shouldMergeCellsVertically(colIdx int, hint renderHint) bool
		Implements (at least one exported)
			*T : Writer

	 type TitleOptions (struct)
		TitleOptions defines the way the title text is to be rendered.

		Fields (total 3, all are exported)
			Align text.Align
			Colors text.Colors
			Format text.Format
		As Types Of (total 15, all are exported)
			  var TitleOptionsBlackOnBlue
			  var TitleOptionsBlackOnCyan
			  var TitleOptionsBlackOnGreen
			  var TitleOptionsBlackOnMagenta
			  var TitleOptionsBlackOnRed
			  var TitleOptionsBlackOnYellow
			  var TitleOptionsBlueOnBlack
			  var TitleOptionsBright
			  var TitleOptionsCyanOnBlack
			  var TitleOptionsDark
			  var TitleOptionsDefault
			  var TitleOptionsGreenOnBlack
			  var TitleOptionsMagentaOnBlack
			  var TitleOptionsRedOnBlack
			  var TitleOptionsYellowOnBlack

	 type WidthEnforcer (func)
		WidthEnforcer is a function that helps enforce a width condition on a string.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func ColumnConfig.getWidthMaxEnforcer() WidthEnforcer

	 type Writer (interface)
		Writer declares the interfaces that can be used to setup and render a table.

		Methods (total 27, all are exported)
			( T) AppendFooter(row Row, configs ...RowConfig)
			( T) AppendHeader(row Row, configs ...RowConfig)
			( T) AppendRow(row Row, configs ...RowConfig)
			( T) AppendRows(rows []Row, configs ...RowConfig)
			( T) AppendSeparator()
			( T) Length() int
			( T) Render() string
			( T) RenderCSV() string
			( T) RenderHTML() string
			( T) RenderMarkdown() string
			( T) ResetFooters()
			( T) ResetHeaders()
			( T) ResetRows()
			( T) SetAllowedRowLength(length int)
			( T) SetAutoIndex(autoIndex bool)
			( T) SetCaption(format string, a ...interface{})
			( T) SetColumnConfigs(configs []ColumnConfig)
			( T) SetHTMLCSSClass(cssClass string)
				deprecated; in favor of Style().HTML.CSSClass

			( T) SetIndexColumn(colNum int)
			( T) SetOutputMirror(mirror io.Writer)
			( T) SetPageSize(numLines int)
			( T) SetRowPainter(painter RowPainter)
			( T) SetStyle(style Style)
			( T) SetTitle(format string, a ...interface{})
			( T) SortBy(sortBy []SortBy)
			( T) Style() *Style
			( T) SuppressEmptyColumns()
		Implemented By (at least one exported)
			*Table
		As Outputs Of (at least one exported)
			func NewWriter() Writer

	/* 3 unexporteds ... *//* 3 unexporteds: */
	 type renderHint (struct)
		renderHint has hints for the Render*() logic

		Fields (total 12, none are exported)
			/* 12 unexporteds ... *//* 12 unexporteds: */
			isAutoIndexColumn bool
				// auto-index column?

			isAutoIndexRow bool
				// auto-index row?

			isBorderBottom bool
				// bottom-border?

			isBorderTop bool
				// top-border?

			isFirstRow bool
				// first-row of header/footer/regular-rows?

			isFooterRow bool
				// footer row?

			isHeaderRow bool
				// header row?

			isLastLineOfRow bool
				// last-line of the current row?

			isLastRow bool
				// last-row of header/footer/regular-rows?

			isSeparatorRow bool
				// separator row?

			rowLineNumber int
				// the line number for a multi-line row

			rowNumber int
				// the row number/index

		Methods (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*T) isHeaderOrFooterSeparator() bool
			(*T) isLastLineOfLastRow() bool
			(*T) isRegularRow() bool
		As Inputs Of (at least 36, none are exported)
			/* 36+ unexporteds ... *//* 36+ unexporteds: */
			func (*Table).analyzeAndStringify(row Row, hint renderHint) rowStr
			func (*Table).csvRenderRow(out *strings.Builder, row rowStr, hint renderHint)
			func (*Table).csvRenderRows(out *strings.Builder, rows []rowStr, hint renderHint)
			func (*Table).getAlign(colIdx int, hint renderHint) text.Align
			func (*Table).getBorderColors(hint renderHint) text.Colors
			func (*Table).getColumnColors(colIdx int, hint renderHint) text.Colors
			func (*Table).getColumnSeparator(row rowStr, colIdx int, hint renderHint) string
			func (*Table).getColumnSeparatorNonBorder(mergeCellsAbove bool, mergeCellsBelow bool, colIdx int, hint renderHint) string
			func (*Table).getColumnSeparatorNonBorderAutoIndex(mergeNextCol bool, hint renderHint) string
			func (*Table).getColumnTransformer(colIdx int, hint renderHint) text.Transformer
			func (*Table).getFormat(hint renderHint) text.Format
			func (*Table).getRow(rowIdx int, hint renderHint) rowStr
			func (*Table).getRowConfig(hint renderHint) RowConfig
			func (*Table).getSeparatorColors(hint renderHint) text.Colors
			func (*Table).getVAlign(colIdx int, hint renderHint) text.VAlign
			func (*Table).htmlRenderColumnAttributes(out *strings.Builder, row rowStr, colIdx int, hint renderHint)
			func (*Table).htmlRenderColumnAutoIndex(out *strings.Builder, hint renderHint)
			func (*Table).htmlRenderRow(out *strings.Builder, row rowStr, hint renderHint)
			func (*Table).htmlRenderRows(out *strings.Builder, rows []rowStr, hint renderHint)
			func (*Table).initForRenderRowsStringify(rows []Row, hint renderHint) []rowStr
			func (*Table).isIndexColumn(colIdx int, hint renderHint) bool
			func (*Table).markdownRenderRow(out *strings.Builder, row rowStr, hint renderHint)
			func (*Table).markdownRenderRows(out *strings.Builder, rows []rowStr, hint renderHint)
			func (*Table).renderColumn(out *strings.Builder, row rowStr, colIdx int, maxColumnLength int, hint renderHint) int
			func (*Table).renderColumnAutoIndex(out *strings.Builder, hint renderHint)
			func (*Table).renderColumnColorized(out *strings.Builder, colIdx int, colStr string, hint renderHint)
			func (*Table).renderColumnSeparator(out *strings.Builder, row rowStr, colIdx int, hint renderHint)
			func (*Table).renderLine(out *strings.Builder, row rowStr, hint renderHint)
			func (*Table).renderMarginLeft(out *strings.Builder, hint renderHint)
			func (*Table).renderMarginRight(out *strings.Builder, hint renderHint)
			func (*Table).renderRow(out *strings.Builder, row rowStr, hint renderHint)
			func (*Table).renderRows(out *strings.Builder, rows []rowStr, hint renderHint)
			func (*Table).renderRowSeparator(out *strings.Builder, hint renderHint)
			func (*Table).shouldMergeCellsHorizontallyAbove(row rowStr, colIdx int, hint renderHint) bool
			func (*Table).shouldMergeCellsHorizontallyBelow(row rowStr, colIdx int, hint renderHint) bool
			func (*Table).shouldMergeCellsVertically(colIdx int, hint renderHint) bool

	 type rowsSorter (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			rows []rowStr
			sortBy []SortBy
			sortedIndices []int
		Methods (total 3, all are exported)
			( T) Len() int
			( T) Less(i, j int) bool
			( T) Swap(i, j int)
		Implements (at least one exported)
			 T : sort.Interface

	 type rowStr ([]T)
		rowStr defines a single row in the Table comprised of just string objects.

		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			( T) areEqual(colIdx1 int, colIdx2 int) bool
				areEqual returns true if the contents of the 2 given columns are the same

		As Outputs Of (at least 4, none are exported)
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			func (*Table).analyzeAndStringify(row Row, hint renderHint) rowStr
			func (*Table).getAutoIndexColumnIDs() rowStr
			func (*Table).getRow(rowIdx int, hint renderHint) rowStr
			func (*Table).initForRenderRowsStringify(rows []Row, hint renderHint) []rowStr
		As Inputs Of (at least 15, none are exported)
			/* 15+ unexporteds ... *//* 15+ unexporteds: */
			func (*Table).csvRenderRow(out *strings.Builder, row rowStr, hint renderHint)
			func (*Table).csvRenderRows(out *strings.Builder, rows []rowStr, hint renderHint)
			func (*Table).getColumnSeparator(row rowStr, colIdx int, hint renderHint) string
			func (*Table).htmlRenderColumnAttributes(out *strings.Builder, row rowStr, colIdx int, hint renderHint)
			func (*Table).htmlRenderRow(out *strings.Builder, row rowStr, hint renderHint)
			func (*Table).htmlRenderRows(out *strings.Builder, rows []rowStr, hint renderHint)
			func (*Table).markdownRenderRow(out *strings.Builder, row rowStr, hint renderHint)
			func (*Table).markdownRenderRows(out *strings.Builder, rows []rowStr, hint renderHint)
			func (*Table).renderColumn(out *strings.Builder, row rowStr, colIdx int, maxColumnLength int, hint renderHint) int
			func (*Table).renderColumnSeparator(out *strings.Builder, row rowStr, colIdx int, hint renderHint)
			func (*Table).renderLine(out *strings.Builder, row rowStr, hint renderHint)
			func (*Table).renderRow(out *strings.Builder, row rowStr, hint renderHint)
			func (*Table).renderRows(out *strings.Builder, rows []rowStr, hint renderHint)
			func (*Table).shouldMergeCellsHorizontallyAbove(row rowStr, colIdx int, hint renderHint) bool
			func (*Table).shouldMergeCellsHorizontallyBelow(row rowStr, colIdx int, hint renderHint) bool


Package-Level Functions (total 4, in which 2 are exported)

	 func AutoIndexColumnID(colIdx int) string
		AutoIndexColumnID returns a unique Column ID/Name for the given Column Number.
		The functionality is similar to what you get in an Excel spreadsheet w.r.t.
		the Column ID/Name.

	 func NewWriter() Writer
		NewWriter initializes and returns a Writer.

	/* 2 unexporteds ... *//* 2 unexporteds: */
	 func isNumber(x interface{}) bool
		isNumber returns true if the argument is a numeric type; false otherwise.

	 func widthEnforcerNone(col string, maxLen int) string
		widthEnforcerNone returns the input string as is without any modifications.


Package-Level Variables (total 61, in which 59 are exported)

	  var ColorOptionsBlackOnBlueWhite ColorOptions
		ColorOptionsBlackOnBlueWhite renders Black text on Blue/White background.

	  var ColorOptionsBlackOnCyanWhite ColorOptions
		ColorOptionsBlackOnCyanWhite renders Black text on Cyan/White background.

	  var ColorOptionsBlackOnGreenWhite ColorOptions
		ColorOptionsBlackOnGreenWhite renders Black text on Green/White
		background.

	  var ColorOptionsBlackOnMagentaWhite ColorOptions
		ColorOptionsBlackOnMagentaWhite renders Black text on Magenta/White
		background.

	  var ColorOptionsBlackOnRedWhite ColorOptions
		ColorOptionsBlackOnRedWhite renders Black text on Red/White background.

	  var ColorOptionsBlackOnYellowWhite ColorOptions
		ColorOptionsBlackOnYellowWhite renders Black text on Yellow/White
		background.

	  var ColorOptionsBlueWhiteOnBlack ColorOptions
		ColorOptionsBlueWhiteOnBlack renders Blue/White text on Black background.

	  var ColorOptionsBright ColorOptions
		ColorOptionsBright renders dark text on bright background.

	  var ColorOptionsCyanWhiteOnBlack ColorOptions
		ColorOptionsCyanWhiteOnBlack renders Cyan/White text on Black background.

	  var ColorOptionsDark ColorOptions
		ColorOptionsDark renders bright text on dark background.

	  var ColorOptionsDefault ColorOptions
		ColorOptionsDefault defines sensible ANSI color options - basically NONE.

	  var ColorOptionsGreenWhiteOnBlack ColorOptions
		ColorOptionsGreenWhiteOnBlack renders Green/White text on Black
		background.

	  var ColorOptionsMagentaWhiteOnBlack ColorOptions
		ColorOptionsMagentaWhiteOnBlack renders Magenta/White text on Black
		background.

	  var ColorOptionsRedWhiteOnBlack ColorOptions
		ColorOptionsRedWhiteOnBlack renders Red/White text on Black background.

	  var ColorOptionsYellowWhiteOnBlack ColorOptions
		ColorOptionsYellowWhiteOnBlack renders Yellow/White text on Black
		background.

	  var DefaultHTMLOptions HTMLOptions
		DefaultHTMLOptions defines sensible HTML rendering defaults.

	  var FormatOptionsDefault FormatOptions
		FormatOptionsDefault defines sensible formatting options.

	  var OptionsDefault Options
		OptionsDefault defines sensible global options.

	  var OptionsNoBorders Options
		OptionsNoBorders sets up a table without any borders.

	  var OptionsNoBordersAndSeparators Options
		OptionsNoBordersAndSeparators sets up a table without any borders or
		separators.

	  var StyleBold Style
		StyleBold renders a Table like below:
		 ┏━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
		 ┃   # ┃ FIRST NAME ┃ LAST NAME ┃ SALARY ┃                             ┃
		 ┣━━━━━╋━━━━━━━━━━━━╋━━━━━━━━━━━╋━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
		 ┃   1 ┃ Arya       ┃ Stark     ┃   3000 ┃                             ┃
		 ┃  20 ┃ Jon        ┃ Snow      ┃   2000 ┃ You know nothing, Jon Snow! ┃
		 ┃ 300 ┃ Tyrion     ┃ Lannister ┃   5000 ┃                             ┃
		 ┣━━━━━╋━━━━━━━━━━━━╋━━━━━━━━━━━╋━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
		 ┃     ┃            ┃ TOTAL     ┃  10000 ┃                             ┃
		 ┗━━━━━┻━━━━━━━━━━━━┻━━━━━━━━━━━┻━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

	  var StyleBoxBold BoxStyle
		StyleBoxBold defines a Boxed-Table like below:
		 ┏━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
		 ┃   # ┃ FIRST NAME ┃ LAST NAME ┃ SALARY ┃                             ┃
		 ┣━━━━━╋━━━━━━━━━━━━╋━━━━━━━━━━━╋━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
		 ┃   1 ┃ Arya       ┃ Stark     ┃   3000 ┃                             ┃
		 ┃  20 ┃ Jon        ┃ Snow      ┃   2000 ┃ You know nothing, Jon Snow! ┃
		 ┃ 300 ┃ Tyrion     ┃ Lannister ┃   5000 ┃                             ┃
		 ┣━━━━━╋━━━━━━━━━━━━╋━━━━━━━━━━━╋━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
		 ┃     ┃            ┃ TOTAL     ┃  10000 ┃                             ┃
		 ┗━━━━━┻━━━━━━━━━━━━┻━━━━━━━━━━━┻━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

	  var StyleBoxDefault BoxStyle
		StyleBoxDefault defines a Boxed-Table like below:
		 +-----+------------+-----------+--------+-----------------------------+
		 |   # | FIRST NAME | LAST NAME | SALARY |                             |
		 +-----+------------+-----------+--------+-----------------------------+
		 |   1 | Arya       | Stark     |   3000 |                             |
		 |  20 | Jon        | Snow      |   2000 | You know nothing, Jon Snow! |
		 | 300 | Tyrion     | Lannister |   5000 |                             |
		 +-----+------------+-----------+--------+-----------------------------+
		 |     |            | TOTAL     |  10000 |                             |
		 +-----+------------+-----------+--------+-----------------------------+

	  var StyleBoxDouble BoxStyle
		StyleBoxDouble defines a Boxed-Table like below:
		 ╔═════╦════════════╦═══════════╦════════╦═════════════════════════════╗
		 ║   # ║ FIRST NAME ║ LAST NAME ║ SALARY ║                             ║
		 ╠═════╬════════════╬═══════════╬════════╬═════════════════════════════╣
		 ║   1 ║ Arya       ║ Stark     ║   3000 ║                             ║
		 ║  20 ║ Jon        ║ Snow      ║   2000 ║ You know nothing, Jon Snow! ║
		 ║ 300 ║ Tyrion     ║ Lannister ║   5000 ║                             ║
		 ╠═════╬════════════╬═══════════╬════════╬═════════════════════════════╣
		 ║     ║            ║ TOTAL     ║  10000 ║                             ║
		 ╚═════╩════════════╩═══════════╩════════╩═════════════════════════════╝

	  var StyleBoxLight BoxStyle
		StyleBoxLight defines a Boxed-Table like below:
		 ┌─────┬────────────┬───────────┬────────┬─────────────────────────────┐
		 │   # │ FIRST NAME │ LAST NAME │ SALARY │                             │
		 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
		 │   1 │ Arya       │ Stark     │   3000 │                             │
		 │  20 │ Jon        │ Snow      │   2000 │ You know nothing, Jon Snow! │
		 │ 300 │ Tyrion     │ Lannister │   5000 │                             │
		 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
		 │     │            │ TOTAL     │  10000 │                             │
		 └─────┴────────────┴───────────┴────────┴─────────────────────────────┘

	  var StyleBoxRounded BoxStyle
		StyleBoxRounded defines a Boxed-Table like below:
		 ╭─────┬────────────┬───────────┬────────┬─────────────────────────────╮
		 │   # │ FIRST NAME │ LAST NAME │ SALARY │                             │
		 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
		 │   1 │ Arya       │ Stark     │   3000 │                             │
		 │  20 │ Jon        │ Snow      │   2000 │ You know nothing, Jon Snow! │
		 │ 300 │ Tyrion     │ Lannister │   5000 │                             │
		 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
		 │     │            │ TOTAL     │  10000 │                             │
		 ╰─────┴────────────┴───────────┴────────┴─────────────────────────────╯

	  var StyleColoredBlackOnBlueWhite Style
		StyleColoredBlackOnBlueWhite renders a Table without any borders or
		separators, and with Black text on Blue background for Header/Footer and
		White background for other rows.

	  var StyleColoredBlackOnCyanWhite Style
		StyleColoredBlackOnCyanWhite renders a Table without any borders or
		separators, and with Black text on Cyan background for Header/Footer and
		White background for other rows.

	  var StyleColoredBlackOnGreenWhite Style
		StyleColoredBlackOnGreenWhite renders a Table without any borders or
		separators, and with Black text on Green background for Header/Footer and
		White background for other rows.

	  var StyleColoredBlackOnMagentaWhite Style
		StyleColoredBlackOnMagentaWhite renders a Table without any borders or
		separators, and with Black text on Magenta background for Header/Footer and
		White background for other rows.

	  var StyleColoredBlackOnRedWhite Style
		StyleColoredBlackOnRedWhite renders a Table without any borders or
		separators, and with Black text on Red background for Header/Footer and
		White background for other rows.

	  var StyleColoredBlackOnYellowWhite Style
		StyleColoredBlackOnYellowWhite renders a Table without any borders or
		separators, and with Black text on Yellow background for Header/Footer and
		White background for other rows.

	  var StyleColoredBlueWhiteOnBlack Style
		StyleColoredBlueWhiteOnBlack renders a Table without any borders or
		separators, and with Header/Footer in Blue text and other rows with
		White text, all on Black background.

	  var StyleColoredBright Style
		StyleColoredBright renders a Table without any borders or separators,
		and with Black text on Cyan background for Header/Footer and
		White background for other rows.

	  var StyleColoredCyanWhiteOnBlack Style
		StyleColoredCyanWhiteOnBlack renders a Table without any borders or
		separators, and with Header/Footer in Cyan text and other rows with
		White text, all on Black background.

	  var StyleColoredDark Style
		StyleColoredDark renders a Table without any borders or separators, and
		with Header/Footer in Cyan text and other rows with White text, all on
		Black background.

	  var StyleColoredGreenWhiteOnBlack Style
		StyleColoredGreenWhiteOnBlack renders a Table without any borders or
		separators, and with Header/Footer in Green text and other rows with
		White text, all on Black background.

	  var StyleColoredMagentaWhiteOnBlack Style
		StyleColoredMagentaWhiteOnBlack renders a Table without any borders or
		separators, and with Header/Footer in Magenta text and other rows with
		White text, all on Black background.

	  var StyleColoredRedWhiteOnBlack Style
		StyleColoredRedWhiteOnBlack renders a Table without any borders or
		separators, and with Header/Footer in Red text and other rows with
		White text, all on Black background.

	  var StyleColoredYellowWhiteOnBlack Style
		StyleColoredYellowWhiteOnBlack renders a Table without any borders or
		separators, and with Header/Footer in Yellow text and other rows with
		White text, all on Black background.

	  var StyleDefault Style
		StyleDefault renders a Table like below:
		 +-----+------------+-----------+--------+-----------------------------+
		 |   # | FIRST NAME | LAST NAME | SALARY |                             |
		 +-----+------------+-----------+--------+-----------------------------+
		 |   1 | Arya       | Stark     |   3000 |                             |
		 |  20 | Jon        | Snow      |   2000 | You know nothing, Jon Snow! |
		 | 300 | Tyrion     | Lannister |   5000 |                             |
		 +-----+------------+-----------+--------+-----------------------------+
		 |     |            | TOTAL     |  10000 |                             |
		 +-----+------------+-----------+--------+-----------------------------+

	  var StyleDouble Style
		StyleDouble renders a Table like below:
		 ╔═════╦════════════╦═══════════╦════════╦═════════════════════════════╗
		 ║   # ║ FIRST NAME ║ LAST NAME ║ SALARY ║                             ║
		 ╠═════╬════════════╬═══════════╬════════╬═════════════════════════════╣
		 ║   1 ║ Arya       ║ Stark     ║   3000 ║                             ║
		 ║  20 ║ Jon        ║ Snow      ║   2000 ║ You know nothing, Jon Snow! ║
		 ║ 300 ║ Tyrion     ║ Lannister ║   5000 ║                             ║
		 ╠═════╬════════════╬═══════════╬════════╬═════════════════════════════╣
		 ║     ║            ║ TOTAL     ║  10000 ║                             ║
		 ╚═════╩════════════╩═══════════╩════════╩═════════════════════════════╝

	  var StyleLight Style
		StyleLight renders a Table like below:
		 ┌─────┬────────────┬───────────┬────────┬─────────────────────────────┐
		 │   # │ FIRST NAME │ LAST NAME │ SALARY │                             │
		 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
		 │   1 │ Arya       │ Stark     │   3000 │                             │
		 │  20 │ Jon        │ Snow      │   2000 │ You know nothing, Jon Snow! │
		 │ 300 │ Tyrion     │ Lannister │   5000 │                             │
		 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
		 │     │            │ TOTAL     │  10000 │                             │
		 └─────┴────────────┴───────────┴────────┴─────────────────────────────┘

	  var StyleRounded Style
		StyleRounded renders a Table like below:
		 ╭─────┬────────────┬───────────┬────────┬─────────────────────────────╮
		 │   # │ FIRST NAME │ LAST NAME │ SALARY │                             │
		 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
		 │   1 │ Arya       │ Stark     │   3000 │                             │
		 │  20 │ Jon        │ Snow      │   2000 │ You know nothing, Jon Snow! │
		 │ 300 │ Tyrion     │ Lannister │   5000 │                             │
		 ├─────┼────────────┼───────────┼────────┼─────────────────────────────┤
		 │     │            │ TOTAL     │  10000 │                             │
		 ╰─────┴────────────┴───────────┴────────┴─────────────────────────────╯

	  var TitleOptionsBlackOnBlue TitleOptions
		TitleOptionsBlackOnBlue renders Black text on Blue background.

	  var TitleOptionsBlackOnCyan TitleOptions
		TitleOptionsBlackOnCyan renders Black Bold text on Cyan background.

	  var TitleOptionsBlackOnGreen TitleOptions
		TitleOptionsBlackOnGreen renders Black Bold text onGreen background.

	  var TitleOptionsBlackOnMagenta TitleOptions
		TitleOptionsBlackOnMagenta renders Black Bold text on Magenta background.

	  var TitleOptionsBlackOnRed TitleOptions
		TitleOptionsBlackOnRed renders Black Bold text on Red background.

	  var TitleOptionsBlackOnYellow TitleOptions
		TitleOptionsBlackOnYellow renders Black Bold text on Yellow background.

	  var TitleOptionsBlueOnBlack TitleOptions
		TitleOptionsBlueOnBlack renders Blue Bold text on Black background.

	  var TitleOptionsBright TitleOptions
		TitleOptionsBright renders Bright Bold text on Dark background.

	  var TitleOptionsCyanOnBlack TitleOptions
		TitleOptionsCyanOnBlack renders Cyan Bold text on Black background.

	  var TitleOptionsDark TitleOptions
		TitleOptionsDark renders Dark Bold text on Bright background.

	  var TitleOptionsDefault TitleOptions
		TitleOptionsDefault defines sensible title options - basically NONE.

	  var TitleOptionsGreenOnBlack TitleOptions
		TitleOptionsGreenOnBlack renders Green Bold text on Black background.

	  var TitleOptionsMagentaOnBlack TitleOptions
		TitleOptionsMagentaOnBlack renders Magenta Bold text on Black background.

	  var TitleOptionsRedOnBlack TitleOptions
		TitleOptionsRedOnBlack renders Red Bold text on Black background.

	  var TitleOptionsYellowOnBlack TitleOptions
		TitleOptionsYellowOnBlack renders Yellow Bold text on Black background.

	/* 2 unexporteds ... *//* 2 unexporteds: */
	  var styleBoxTest BoxStyle
		styleBoxTest defines a Boxed-Table like below:
		 (-----^------------^-----------^--------^-----------------------------)
		 [<  #>|<FIRST NAME>|<LAST NAME>|<SALARY>|<                           >]
		 {-----+------------+-----------+--------+-----------------------------}
		 [<  1>|<Arya      >|<Stark    >|<  3000>|<                           >]
		 [< 20>|<Jon       >|<Snow     >|<  2000>|<You know nothing, Jon Snow!>]
		 [<300>|<Tyrion    >|<Lannister>|<  5000>|<                           >]
		 {-----+------------+-----------+--------+-----------------------------}
		 [<   >|<          >|<TOTAL    >|< 10000>|<                           >]
		 \-----v------------v-----------v--------v-----------------------------/

	  var styleTest Style
		styleTest renders a Table like below:
		 (-----^------------^-----------^--------^-----------------------------)
		 [<  #>|<FIRST NAME>|<LAST NAME>|<SALARY>|<                           >]
		 {-----+------------+-----------+--------+-----------------------------}
		 [<  1>|<Arya      >|<Stark    >|<  3000>|<                           >]
		 [< 20>|<Jon       >|<Snow     >|<  2000>|<You know nothing, Jon Snow!>]
		 [<300>|<Tyrion    >|<Lannister>|<  5000>|<                           >]
		 {-----+------------+-----------+--------+-----------------------------}
		 [<   >|<          >|<TOTAL    >|< 10000>|<                           >]
		 \-----v------------v-----------v--------v-----------------------------/


Package-Level Constants (total 5, all are exported)

	const Asc SortMode = 0
		Asc sorts the column in Ascending order alphabetically.

	const AscNumeric SortMode = 1
		AscNumeric sorts the column in Ascending order numerically.

	const DefaultHTMLCSSClass = "go-pretty-table"
		DefaultHTMLCSSClass stores the css-class to use when none-provided via
		SetHTMLCSSClass(cssClass string).

	const Dsc SortMode = 2
		Dsc sorts the column in Descending order alphabetically.

	const DscNumeric SortMode = 3
		DscNumeric sorts the column in Descending order numerically.

The pages are generated with Golds v0.3.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.